perm filename CORE[KA,SYS] blob sn#223195 filedate 1976-07-06 generic text, type C, neo UTF8
COMMENT ⊗   VALID 00031 PAGES
C REC  PAGE   DESCRIPTION
C00001 00001
C00004 00002	SUBTTL	CORE ROUTINES FOR SWAPPING SYSTEM. 4 AUG 67 ↔ BEGIN CORE
C00011 00003	CORINI	INITIALIZE CORE TABLES
C00017 00004	CORE UUO	CORUUO, UCORE, RUNCOR
C00023 00005	CHKSHF - THE CORE SHUFFLER		CHKSHF, SPWCNT
C00032 00006	SUBTTL	ANYACT	ROUTINE TO TEST FOR ANY ACTIVE DEVICES
C00039 00007	SUBTTL	CORE0
C00043 00008	CORE1, SHFCOR
C00050 00009	CORGET, BAKOLD, CORG1
C00057 00010	DIDDLE		DIDLE, DIDLEA, DIDLE2
C00064 00011	HOLSRC	
C00067 00012	CORCHK AND CORTCK  -- CHECK CORTAL AGAINST CORTAB AND CHECK CORTAB AGAINST WORLD
C00072 00013	CORSTG - SET AND CLEAR CORE USE TABLE CORGBP,CORSGT
C00077 00014	GETPR	GET A JOB'S PROTECTION-RELOCATION
C00081 00015	SUBTTL	RELOCA
C00089 00016	LOCK AND UNLOCK UUOS.
C00099 00017	LTHMOV, HTLMOV
C00108 00018	SUBTTL	FREE STORAGE	AND OTHER POLITICAL PRISONERS
C00109 00019	INITIALIZE FREE STORAGE - FSINIT
C00116 00020	COMMENT $	FSGET:	GET FREE STORAGE AT ANY LEVEL.
C00133 00021	SWIPE 1K FROM AVAILABLE USER SPACE.
C00138 00022	FSCLK:	CLOCK LEVEL (CHANNEL 7) ROUTINES TO KEEP FREE STORAGE HAPPY!
C00144 00023	FSQUIK, FSGIVE - RETURN FREE STORAGE TO SYSTEM.
C00156 00024	GET FREE STORAGE AT UUO LEVEL.
C00157 00025	RELPDL - RELEASE THE JBTPDL
C00159 00026	SPARE LIST HANDLER FOR DPYSER & TTYSER -- SFSINI SFSCLK
C00162 00027	VERSION OF FSGET TO USE SPARE LIST -- SFSGET
C00165 00028	ARRRGH! PI LEVEL AND NO FAILURE POSSIBLE! HERE WE CURL UP AND DIE
C00166 00029	VERSION OF FSGIVE TO THINK ABOUT PUTTING RETURNED BLOCK INTO SPARE LIST -- SFSGIV SFSREL
C00168 00030	YES FANS, IT'S THE INFAMOUS RELEX, FORMERLY SCATTERED THROUGH TTYSER & DPYSER
C00171 00031	GETMAP,GIVMAP	MANIPULATE 512-WORD PAGES OF FREE STORAGE.
C00174 ENDMK
C⊗;
SUBTTL	CORE ROUTINES FOR SWAPPING SYSTEM. 4 AUG 67 ↔ BEGIN CORE

COMMENT $

Core is allocated on a 512-word page basis.  A table of 9-bit bytes
CORTAB is kept in which each byte corresponds to a page of addressable
memory.  [In the FTPAGER version, these bytes are sliced out of the CST.]
Each byte is marked with one of the following codes:

	0	Block is available.
	1-77	Block is in use by the job named in this code
	101	Block is occupied bt the system
	103	Block does not exist (NXM)
	105	Block is in use by system as free storage.
	110	Block is in use as a page table (not as free storage)

When the system is initialized, CORINI sets the CORTAB table to
reflect blocks in use by the system and non-existant blocks.

RMEMSIZ	minimum of total memory size and 1000000
37	(system JOBREL for Exec DDT) is one less than RMEMSIZ
MEMSIZ	address of the bottom of free storage
CORMAX	number of words of low core free (MEMSIZ-SYSTOP)
CORTAL	numbr of pages of low core free
LOKTOP	bottom address of unlocked core (initially same as SYSTOP)
SYSTOP	bottom address of user space.
TMEMSIZ	total memory size in entire system (may exceed 1000000)

FSINIT completes the task of initializing core.  FSINIT is called for
every 200 restart, initialization, or reload.  FSINIT unlocks any
locked core, returns any claimed free storage to the general core
pool and then initializes free storage to contain one block of size
FSNINIT*1024 words. 

The area between LOKTOP and MEMSIZ (LOKPAG-MEMPAG) is available
for allocation to users.  Also the area between FHUPAG and LHUPAG
may be allocated as high core.  Locked core affects LOKTOP/LOKPAG.
Free storage affects MEMSIZ/MEMPAG.

Core routines affect the following globals (and others!):
JBTPAG, CORTAL, CORTAB, HOLEF, SHFWAT, JBTMAP.

Core Allocation Routines:

Generally TAC must be setup to the desired core size for the job
whose number is in J.

CORUUO is called by the CORE UUO, CORE2 and REMAP UUOs.  For lowers,
there is already core in core.  For uppers, there may not be any
physical core assigned.  CORUUO calls UCORE.  CORUUO stores the
number of free blocks available by calling STOTAC.

UCORE is called by CORUUO and by BUFCLC, always at UUO level.  UCORE
calls IOWAIT to wait for IO to stop, then calls either CORE1 or CORE0
(CORE0 if there's no core assigned to this job), upon return WSCHED
is called, because resulting core may be assigned on swapping disk.

RUNCOR is called at UUO level (monitor job) for SAVGET.  Core already
is assigned to the job.  Calls CORE1 then WSCHED.  Unlike CORUUO,
RUNCOR does not store the number of free blocks into user's core.

CORE0 is called at clock level.  If job already has core in core, it calls
CORE1.  CORE0 is used by ZEROSEG, FINOUT (to release core), by KILCM7
and RUNCOM (to assign a job data area) and by the console CORE
command to change a job's core assignment without running that job.
If a job has no core in core (either swapped out, or NULQ) then CORE0
will assign core on the disk.

CORE1 is called at any level.  Job must already have some core.  The
new core assignment may be zero.

CORGET is called if a job has no core (or when it's core has been
temporarily marked free prior to assigning new core).  Called by
CORE1 and INJOB.

CORGET assigns core to a job, if possible, sets the use code in
CORTAB, and moves the job if this assignment is at a different place
than the old core.  If CORGET can't assign new core, it restores the
old assignment, if any, and calls XPAND to cause the job to be
swapped out.  Then the swap-in process will assign new core.

The table, JBTPAG, is updated by the core routines.  For each job in
core, JBTPAG is the number of pages,,first page.  JBTADR is computed
from JBTPAG.  JBTADR contains the protection (size) and relocation
for each job in core.  Also, JOBREL in the user's core image is
modified by the core routines.  If the current job is changing its
core allocation, the APR map is changed accordingly.  JBTMAP entries
for each job are maintained to correspond to JBTPAG.

$


;Special AC names (also TAC, TAC1, PROG, IOS, DDB, and P are used)

BLK←AC1		;HIGHEST REL. ADR. IN USER AREA
LOC←DSER	;ABS. LOC. OF FIRST BLOCK IN USER AREA
;CORINI	INITIALIZE CORE TABLES
;REG THIS PAGE. 1972: 22 FEB, 15 APRIL, 28 APRIL.
;HISYS REVISIONS.  REG 12/75  1/76

↑CORINI:MOVE	TAC,[XWD CORBEG,CORBEG+1]
	SETZM	CORBEG
	BLT	TAC,COREND

NOKL10,<	CONO	APR,NXM			;CLEAR NXM>

IFKL10,<	CONO	APR,KLCLRF!7740		;CLEAR NXM, ETC.
		PUSH	P,KLUPT+KLPFNP		;SAVE STANDARD PAGE FAULT TRAP
		MOVEI	TAC,CORIPF		;OUR TRAP HANDLER
		MOVEM	TAC,KLUPT+KLPFNP	;NEW PC FOR PAGE FAIL
>;IFKL10


;FOR FTEXPG, MAP IS ALREADY SUPPOSED TO BE TURNED ON!
;TRAPS (WHICH SHOULDN'T HAPPEN) WILL GO TO INITRP IN SYSINI

IFN FTEXPG,<	MOVSI	TAC,160040		;PAGE TABLE POINTER TO 0
		MOVEM	TAC,EXPGT+PAREXP	;CLOBBER MAP >;IFN FTEXPG

	MOVSI	AC3,-PHYMEM*2		;NUMBER OF PAGES OF PHYSICAL CORE TO SCAN.
CORI1:	MOVEI	TAC1,(AC3)		;GET PAGE NUMBER
	LSH	TAC1,=9			;SHIFT TO MAKE PHYSICAL ADDRESS

IFN FTEXPG,<	HRRM	AC3,EXPGT+PAREXP  ;STORE PAGE NUMBER TO REFERENCE
NOKL10,<	CONO	PAG,1		;CLEAR ARS MAPPING EXEC PAGES.>;NOKL10
IFKL10,<	CONO	KLPAG,@KLPCON	>;IFKL10
		HLLZ	DAT,20!PAREXP⊗=9 ;REFERENCE MEMORY >;IFN FTEXPG

IFE FTEXPG,<	HLLZ	DAT,(TAC1)	;REFERENCE MEMORY >;IFE FTEXPG

IFN FTHSYS,<	MOVEI	TAC,(AC3)
		CAIL	TAC,1000
		CAML	TAC,FHUPAG	;SKIP IF THIS IS AN HISYS ADDR>;FTHSYS
	CAMGE	TAC1,SYSTOP		;SKIP IF ADDRESS IS BEYOND SYSTEM.
	TROA	DAT,2			;SYSTEM PAGE.  CODE WILL BE 103
NOKL10,<	CONSZ	APR,NXM		;SKIP UNLESS NXM >
IFKL10,<	CONSZ	APR,KLNXM	;SKIP UNLESS NXM >
	TRC	DAT,103			;NXM CODE IS 103, IF SYSTEM, SET TO 101
	MOVEI	LOC,(AC3)
	PUSHJ	P,CORGBP		;COMPUTE BYTE POINTER TO CORTAB
	DPB	DAT,TAC			;MARK CORTAB FOR THIS PAGE.
	TRNE	DAT,2			;SKIP IF NO NXM
	JRST	CORI2			;NXM. QUIT NOW.
	AOBJN	AC3,CORI1		;LOOP IF STILL WITHIN CONFIGURATION LIMIT
	HRRZ	AC3,AC3			;END OF CONFIGURATION AC3←FIRST NXM PAGE
	MOVEI	LOC,(AC3)
	PUSHJ	P,CORGBP
	MOVEI	DAT,103			;CODE FOR NXM
	DPB	DAT,TAC			;STORE NXM BYTE AT END OF CORTAB.
CORI2:	MOVEI	TAC1,(AC3)
	CAILE	TAC1,1000
	MOVEI	TAC1,1000		;RMEMSIZ MAXIMUM IS 1,,0
	LSH	TAC1,=9
	MOVEM	TAC1,RMEMSIZE		;ADDRESS OF FIRST NXM.
	MOVEM	TAC1,MEMSIZ		;SETUP LOWEST ADDRESS IN FREE STORAGE
	MOVE	TAC,TAC1
	LSH	TAC,-=9
	MOVEM	TAC,MEMPAG
	MOVE	TAC,TAC1		;COPY RMEMSIZE
	SUB	TAC,SYSTOP		;MINUS (LOW) SYSTEM SIZE
	MOVEM	TAC,CORMAX		;IS MAXIMUM SIZE OF (LOW) USER CORE.
	LSH	TAC,-=9
	MOVEM	TAC,CORTAL		;NUMBER OF PAGES IN (LOW) USER CORE.
	SUBI	TAC1,1			;DECREMENT TO MAKE SYSTEM JOBREL
	MOVEM	TAC1,37			;SAVE SYSTEM JOBREL FOR EXEC DDT AND UEDDT

IFN FTEXPG,<	ANDI	AC3,-1		;IGNORE LEFT HALF = -PAGES THAT AREN'T THERE
		MOVEI	TAC,(AC3)
		CAIL	TAC,GOODPG	;DID WE SEE ONLY "GOOD" PAGES?
		MOVEI	TAC,GOODPG	;NO.  RESTRICT CORHTL TO GOOD PAGES ONLY
		MOVEM	TAC,LHUPAG	;ONE PAST LAST HIGH USER PAGE.
		SUB	TAC,FHUPAG
		MOVEM	TAC,CORHTL	;NUMBER OF FREE PAGES IN HIGH CORE
		LSH	AC3,=9
		MOVEM	AC3,TMEMSIZ	;SAVE TOTAL MEM FOR PARSER, ETC.
		SETZM	EXPGT+PAREXP	;FLUSH RANDOMNESS FROM EXPGT
NOKL10,<	CONO	PAG,1		;AND FROM THE PAGER >;NOKL10
IFKL10,<	CONO	KLPAG,@KLPCON	>;IFKL10
					 >;FTEXPG

	MOVEI	TAC,%SWPL
;	SKIPN	FBACT
;	MOVEI	TAC,400000	;3330 SWAPPER ONLY WORKS THIS BIG.
;	CAILE	TAC,%SWPL
;	MOVEI	TAC,%SWPL
	MOVEM	TAC,SWAPLI	;SET SYSTEM SWAPLIMIT.

NOKL10,<	CONO	APR,NXM			;CLEAR NXM>
IFKL10,<	CONO	APR,KLCLRF!7740		;CLEAR NXM, ETC.
		POP	P,KLUPT+KLPFNP		>;IFKL10

	POPJ	P,

IFKL10,<
CORIPF:	CONSO	APR,KLNXM			;SEEN A NXM?
	HALT	.				;NO.  NO REASON TO FAULT.
	CONO	APR,KLCLRF!7740-KLNXM		;CLEAR PARITY ERRORS, KEEP NXM
	AOS	KLUPT+KLPFPC			;ADVANCE OVER FAILING INSTR.
	MOVEI	DAT,0
	JRST	2,@KLUPT+KLPFPC
>;IFKL10
SUBTTL	CORE UUO	;CORUUO, UCORE, RUNCOR

COMMENT $

CALL:	MOVEI	AC,<HIGHEST RELATIVE ADDRESS DESIRED>
	CALL	AC,['CORE  ']	OR 	CALLI	AC,11
	<ERROR RETURN: CAN'T ASSIGN CORE>
	OK RETURN.  JOB MAY HAVE BEEN SHUFFLED OR SWAPPED.

The number of 1K blocks that a job may have is returned in the AC.
If called with AC containing zero, then the core allocation is not
changed and the error return is taken with AC returing the number of
free blocks.

CORUUO is called for the CORE UUO, and by REMAP and CORE2 UUOs.
For the CORE2 UUO, J will be setup to the job number of the upper
that's being affected.  Only in the case of the CORE2 UUO is there
the possibility that the job involved has no core assigned prior to
the UUO.

UCORE is called by CORUUO and by BUFCLC (always at UUO level).

RUNCOR is called at UUO level (monitor job) for SAVGET.

$


↑CORUUO:JUMPE	TAC,ZERCOR		;IS ARGUMENT ZERO?
	AOS	(P)			;ASSUME SUCCESS RETURN.
	PUSHJ	P,UCORE			;DO IT.  (CORE1 WILL FORCE UNLOCK)
	SOS	(P)			;BAD ASSUMPTION. FAILURE RETURN.
ZERCOR:	MOVE	TAC,CORMAX		;GET CURRENT FREE SPACE.
	CAMLE	TAC,SWAPLIMIT		;MORE THERE THAN HE CAN HAVE?
	MOVE	TAC,SWAPLIMIT		;YES. TELL HIM MAX WE'LL ALLOW.
	ASH	TAC,-=10		;IN 1 K BLOCKS (KEEP IT THE OLD WAY)
	JRST	STOTAC			;RETURN CORMAX TO USER

;(HERE FROM BUFCLC WITH TAC←DESIRED JOBREL, TO EXPAND CORE FOR IO BUFFERS)
↑UCORE:	IORI	TAC,1777		;ROUND UP TO A 1K BOUNDARY.
	MOVE	TAC1,JBTSTS(J)		;GET JOB STATUS
	TLNN	TAC1,JSEG		;AND SKIP IF THIS IS AN UPPER.
	JRST	CORCS2			;NOT AN UPPER.
	PUSH	P,J			;SAVE UPPER'S JOB NUMBER.
	MOVEI	J,JOBN-1		;LOOK THRU ALL JOBS...
CORCSO:	LDB	TAC1,PSEGN		;DOES THIS GUY POINT TO ME?
	CAME	TAC1,(P)		;SKIP IF A USER OF THIS UPPER.
	JRST	CORCSL			;NO.
	MOVE	TAC1,J			;TAC1 ← JOB NUMBER OF THIS LOWER.
	PUSHJ	P,CORSGT		;GET THE SIZE OF THIS LOWER INTO TAC1
	ADDI	TAC1,1(TAC)		;LOWER SIZE + MY REQUEST SIZE.
CORCS3:	CAMG	TAC1,SWAPLIMIT		;SKIP IF TOO BIG TO SWAP
	CAMLE	TAC1,CORMAX		;SKIP UNLESS TOO BIG TO FIT IN CORE
	JRST	.+2			;TOO BIG
	JRST	CORCSL			;NOT TOO BIG. CHECK OTHER LOWERS.
	POP	P,J			;THIS LOWER AND ME WONT FIT
	POPJ	P,			;GIVE THE ERROR RETURN.

CORCSL:	SOJG	J,CORCSO		;CONTINUE SCAN THRU ALL JOBS.
	POP	P,J			;RESTORE J
	JRST	CORXOK			;SO FAR, SO GOOD.

CORCS2:	LDB	TAC1,PSEGN		;NOT A SEGMENT. HAS IT AN UPPER?
	SKIPE	DAT,TAC1		;SKIP IF NO UPPER. GET NUMBER IN DAT
	PUSHJ	P,CORSGT		;GET SIZE OF UPPER IN TAC1.
	ADDI	TAC1,1(TAC)		;UPPER'S SIZE + THIS REQUEST.
	CAMG	TAC1,SWAPLIMIT		;IS COMBINATION TOO BIG?
	CAMLE	TAC1,CORMAX		;DOES IT FIT?
	POPJ	P,			;NOPE.
CORXOK:	PUSH	P,TAC			;SAVE SIZE WE WANT TO BE.
	PUSH	P,UUO			;SAVE
	PUSH	P,J			;SAVE J IF THIS IS A SEGMENT.
	PUSHJ	P,IOWAIT		;WAIT FOR ALL IO TO STOP.
	JRST	.+2
CORYOK:	PUSHJ	P,WSCHED
	PUSHJ	P,ANYACT		;MAKE SURE WE CAN BE MOVED.
	JRST	CORYOK			;NO. WAIT UNTIL WE CAN.
	POP	P,J			;RESTORE J
	POP	P,UUO
	POP	P,TAC			;HIGHEST REL. LOC. DESIRED
	MOVEI	TAC1,CORE0		;CALL CORE0 IF THERE'S NO CORE ALREADY
	SKIPE	JBTPAG(J)		;SKIP IF THERE IS NO OLD CORE ASSIGNMENT
↑RUNCOR:MOVEI	TAC1,CORE1		;CALL CORE1 IF THERE'S CORE ALREADY.
	AOS	(P)			;SET SKIP RETURN.
	PUSHJ	P,(TAC1)		;REASSIGN CORE, OR GET NEW CORE ON DISK
	SOS	(P)			;FAILURE RETURN.
	PUSHJ	P,WSCHED		;IN CASE CORE IS NOW ON DISK, STOP JOB
	MOVE	TAC1,JBTSTS(J)
	TLNE	TAC1,JSEG		;SKIP IF THIS IS A LOWER.
	PUSHJ	P,UAPPLY		;CONTINUE SPACWAR FOR ALL LOWERS
	 PUSHJ	 P,SPWCNT		;(ARG TO UAPPLY) CONTINUE SPACEWAR FOR LOWER
	POPJ	P,
SUBTTL	CHKSHF - THE CORE SHUFFLER		;CHKSHF, SPWCNT

COMMENT $

The Swapper calls CHKSHF because core is fragmented.  The
fragmentation of core is indicated by CORTAL being sufficient to fit
a job, but CORGET failing to allocate core.  When CHKSHF is called,
the job above the lowest hole in core (the hole is indicated by
HOLEF) is located and if it has no IO (or spacewar) active, it is
shuffled into the bottom of that hole.  In this way core becomes
compacted until a hole sufficiently large for the Swapper's purpose
is created.  If the job to be shuffled has IO active, then SHFWAT is
set to that job's number, the SHF bit is set in his JBTSTS, and
CHKSHF goes away (also spacwar suspension is requested).  Eventually
that job should become shuffleable, and it will be moved.  If SHFWAT
is set, the swapper will call CHKSHF every tick until the job gets
moved.

Note that devices look at the SHF bit in JBTSTS (at ADVBFF and
ADVBFE) to see if the monitor is waiting to shuffle this job.  Also,
the scheduler will not run a job that has SHF set, thus preventing
further IO from being initiated.

The state of the map is supposed to be saved before CHKSHF is called.

$

↑CHKSHF:HGMAC	(26)
	SKIPE	J,SHFWAT	;DID WE STOP A JOB TO WAIT FOR IO INACTIVE?
	JRST	SHFLOP		;YES, SEE IF IO HAS STOPPED YET
	SKIPN	TAC,HOLEF	;NO, DOES CORE HAVE A HOLE IN IT?
	JRST	DIDLE4		;NO?    RECALCUATE SWAPPER'S PARAMETERS.
CHKSHZ:	CAML	TAC,MEMPAG	;SKIP IF HOLEF IS WITHING REASON.
	JRST	CHKERR
	PUSHJ	P,CORGB1	;MAKE A BYTE POINTER FROM HOLEF
	LDB	J,TAC		;GET A USE BYTE
	CAIGE	J,JOBN		;VALIDITY CHECK-SKIP IF ILLEGAL
	JUMPG	J,SHFLOA	;FOUND ONE?
SHFLOB:	PUSHACS
	PUSHJ	P,DISDATE
	PUSHJ	P,DISMES
	ASCIZ	/HOLEF = /
	MOVE	TAC,HOLEF
	PUSHJ	P,DISLOC
	PUSHJ	P,DISMES
	ASCIZ	/  BUT NO HOLE PRESENT. CORTAB = /
	MOVE	TAC,HOLEF
	PUSHJ	P,CORGB1	;GET A BYTE POINTER.
	LDB	J,TAC		;GET THE BYTE.
	PUSHJ	P,DISJOB	;PRINT JOB NAME & NUMBER.
	PUSHJ	P,DISCRLF
	PUSHJ	P,DISFLU
	PUSHJ	P,DDTCAL
	POPACS
	JRST	DIDLE4		;RECALCULATE SWAPPER'S PARAMETERS

CHKERR:	PUSHACS
	PUSHJ	P,DISMES
	ASCIZ	/HOLEF OUT OF BOUNDS = /
	MOVE	TAC,HOLEF
	PUSHJ	P,DISOCT
	PUSHJ	P,DISCRLF
	POPACS
	JRST	DIDLE4		;RECALCULATE HOLEF

SHFLOA:	HRRZ	TAC,JBTPAG(J)
	CAME	TAC,HOLEF
	JRST	SHFLOB		;LOSER!
SHFLOP:	SKIPN	JBTPAG(J)	;SKIP IF THIS JOB IS STILL INCORE.
	JRST	NOTSH1		;NO CORE. HE CAN'T BE SHUFFLED, SO CLEAR SHFWAT
	PUSHJ	P,SHFCOR	;IN A LOWER POSITION IN CORE
	JRST	NOTSHF		;CANNOT ONLY IF IO IS ACTIVE
NOTSH1:	SETZM	SHFWAT		;JOB HAS BEEN SHUFFLED, CLEAR FLAG
	MOVSI	TAC,SHF		;CLEAR SHUFFLE WAIT BIT IN CASE IT WAS ON
	ANDCAB	TAC,JBTSTS(J)
	SKIPN	JBTPAG(J)	;IF WE DON'T HAVE CORE, DON'T CONTINUE SPACEWAR
	JRST	DIDLE4		;GO RECALCULATE SWAPPER'S PARAMETERS
	TLNE	TAC,JSEG	;SKIP UNLESS THIS IS AN UPPER.
	PUSHJ	P,UAPPLY	;FOR UPPERS, CONTINUE SPACEWAR FOR ALL LOWERS.
	 PUSHJ	 P,SPWCNT	;(ARG TO UAPPLY).  FOR LOWER, CONTINUE SPACEWAR
	JRST	DIDLE4		;RECALCULATE SWAPPER'S PARAMETERS


NOTSHF:	SKIPN	HOLEF		;JOB CAN'T BE MOVED.  STILL ACTIVE IO.
	JRST	NOTSH1		;HOLE ISN'T THERE ANYMORE?
	MOVM	TAC,FORCE
	CAME	J,FIT
	CAMN	J,TAC
	JRST	NOTSH1		;IF THIS JOB IS BEING SWAPPED, DON'T SHUFFLE
	MOVEM	J,SHFWAT	;SET SHUFFLE WAIT FLAG WITH JOB NO.
	SKIPE	SP2GO(J)	;DOES THIS JOB HAVE SPACEWAR ACTIVE?
	SKIPN	SP2GO(J)
	JRST	NOTSH5		;NO SPACEWAR ACTIVE
	HLRZ	TAC,JBTST2(J)
	ANDI	TAC,SPWST1!SPWST2
	CAIE	TAC,SPWST1!SPWST2	;SKIP IF SPW IS SUSPENDED.
	POPJ	P,		;UNTIL SPW IS SUSPENDED, ALLOW USER TO RUN
NOTSH5:	MOVSI	TAC,SHF		;SET SHF WAIT BIT IN JOB STATUS WORD
	IORM	TAC,JBTSTS(J)	;TO KEEP THE JOB FROM BEING RUN
	POPJ	P,		;AND IO WILL STOP SOON (WE HOPE)


↑SPWCNT:			;CONTINUE A SPW JOB
	SKIPN	JBTST2(J)	;IS THERE A SPW JOB HERE??
	POPJ	P,		;NO.
	PSYNC	SPWCSC
	MOVSI	TAC,SPWST1!SPWST2	;CLEAR SUSPENSION STATUS
	ANDCAM	TAC,JBTST2(J)
	XSYNC	SPWCSC
	POPJ	P,
SUBTTL	ANYACT	ROUTINE TO TEST FOR ANY ACTIVE DEVICES
COMMENT  $
CALLING
	MOVE	J,JOB NUMBER
	PUSHJ	P,ANYACT
	<HERE IF DEVICES ACTIVE>
	<HERE IF NO DEVICE IS ACTIVE, EXCEPT POSSIBLY TTY>
$

↑ANYACT:
	MOVE	UCHN,JBTSTS(J)		;GET JOB STATUS
	TLNN	UCHN,JSEG		;SKIP IF THIS IS AN UPPER
	JRST	ANYAC3			;THIS IS A LOWER
	PUSH	P,PROG			;SAVE VITAL DATA.
	PUSH	P,J			;SAVE THIS JOB NUMBER.
	AOS	-2(P)			;ASSUME SUCCESS RETURN.
	MOVEI	J,JOBN-1		;SEARCH THRU ALL JOBS.
ANYAC1:	LDB	UCHN,PSEGN		;LOOKING FOR LOWERS THAT POINT HERE
	CAME	UCHN,(P)		;DOES THIS POINT TO ME.
ANYA1A:	SOJG	J,ANYAC1		;NO. DECREMENT J AND LOOP
	JUMPLE	J,ANYAC2		;JUMP IF WE HAVE EXHAUSTED THE LOOP
	PUSHJ	P,ANYAC3		;CALL ROUTINE FOR A LOWER SEGMENT
	SOSA	-2(P)			;CAN'T MOVE THIS LOWER.  SET NO-SKIP
	JRST	ANYA1A			;THIS LOWER DOESN'T CARE IF WE MOVE
ANYAC2:	POP	P,J
	POP	P,PROG
	POPJ	P,

;HERE FOR A LOWER SEGMENT ONLY. 

ANYAC3:	SKIPN	JBTPAG(J)		;ANY CORE THERE?
	JRST	CPOPJ1			;NO CORE MEANS NO IO ACTIVE.
	SKIPN	SP2GO(J)		;IS A P2 SPACEWAR JOB RUNNING?
	SKIPE	SPWGO(J)		;OR IS A P1 SPACEWAR JOB RUNNING?
	CAIA				;SPACEWAR ACTIVE.
	JRST	ANYAC4			;NO SPACEWAR WORRIES.
	PSYNC	SPWCSC
	MOVE	IOS,JBTST2(J)
	TLC	IOS,SPWST1!SPWST2
	TLCN	IOS,SPWST1!SPWST2
	JRST	ANYA3A			;SPW IS SUSPENDED.
	MOVSI	IOS,SPWSUS		;NO. MARK IT FOR SUSPENSION
	TDNN	IOS,JBTST2(J)		;SKIP IF SUSPENSION REQUEST SET ALREADY.
	IORM	IOS,JBTST2(J)		;SET THE BIT THAT REQUESTS SPW SUSPENSION
	XSYNC	SPWCSC
	POPJ	P,			;CAN'T MOVE JOB UNTIL SPACEWAR IS SUSPENDED

ANYA3A:	XSYNC	SPWCSC
ANYAC4:	SKIPN	JBTIIP(J)		;INTERRUPT IN PROGRESS?
	SKIPE	JBTGLU(J)		;NO.  IS SOMEONE GLUEING HIM?
	POPJ	P,			;(JBTGLU OR INTIIP) FAKE ACTIVE DEVICE.
	AOS	(P)			;ASSUME SUCCESS (IT DOES HAPPEN SOMETIMES)
	PUSH	P,TAC			;IMPORTANT THAT WE SAVE TAC!
	PUSHJ	P,ANYAC5
	SOS	-1(P)
	JRST	TPOPJ			;RESTORE TAC AND SKIP OR NOT

ANYAC5:	PUSHJ	P,MAPSET
	CAMN	J,JOB(PID)		;IS THIS THE CURRENT JOB
	PUSHJ	P,S2U			;YES.  COPY USRDAT TO JOBDAT.
	MOVEI	IOS,IOACT		;IO DEVICE ACTIVE BIT
	XCTR	XR,[SKIPGE AC2,JOBHCU]	;AC2←NUMBER OF USER IO CHANNELS IN USE
	MOVNI	AC2,JOBJDA-JOBHCU	;C(JOBHCU) POINTS TO SAVGET DDB
	CAILE	AC2,17			;IS HIGHEST CHANNEL LEGAL?
	JRST	ANYHCC			;JOBHCU IS CLOBBERED.
	MOVSI	TAC1,DVTTY		;DEVICE IS A TTY BIT
ANY:	XCTR	XR,[HRRZ DDB,JOBJDA(AC2)] ;IS A DEVICE ASSIGNED TO THIS CHANNEL?
	JUMPE	DDB,ANY2		;NO.
	CAIL	DDB,CHKBEG		;CHECK ADDRESS. SKIP IF LOW CORE
	CAML	DDB,MEMSIZ		;SKIP IF BELOW F.S. (NO NO)
	CAML	DDB,RMEMSIZ		;BELOW REAL MEM? (REDUNDANT FOR LOW CORE)
	JRST	ANY7			;LOSING ADDRESS
	TDNE	IOS,DEVIOS(DDB)		;YES, IS IT ACTIVE?
	TDNE	TAC1,DEVMOD(DDB)	;YES.  SKIP IF IS NOT A TTY.
	JRST	ANY2
	POPJ	P,

ANY2:	SOJGE	AC2,ANY			;THIS CHANNEL IS OK.
	SKIPA	UCHN,JBTIOP(J)		;GET THE JBTPDL (IF ANY) AND SKIP.
ANY2A:	ADD	UCHN,[2,,2]		;ADVANCE TO NEXT DDB
	JUMPGE	UCHN,CPOPJ1		;JUMP IF IOPDL EXHAUSTED.
	SKIPN	DDB,(UCHN)		;GET DDB POINTER
	JRST	ANY2A			;IGNORE ONES THAT AREN'T THERE
	TDNE	IOS,DEVIOS(DDB)		;IOACT ON?
	TDNE	TAC1,DEVMOD(DDB)	;YES, TTY?
	JRST	ANY2A			;TTY OR NOT IOACT.
	POPJ	P,			;ACTIVE IO

ANY7:	PUSHACS				;DDB ADDRESS IS OUT OF BOUNDS.
	XCTR	XW,[SETZM JOBJDA(AC2)]	;BLAST ILLEGAL DDB POINTER
	SKIPGE	AC2
	XCTR	XW,[SETZM JOBJDA]	;IN CASE IT WAS SAVGET, ZERO CHANNEL 0
	PUSHJ	P,DISDATE
	PUSHJ	P,DISJOB
	PUSHJ	P,DISMES
	ASCIZ	/ ANY7: ILLEGAL DDB ADDRESS = /
	HRRZ	TAC,DDB-17(P)		;PICK UP ADDRESS
	PUSHJ	P,DISLOC		;TYPE ADDRESS IN OCTAL
	PUSHJ	P,DISMES
	ASCIZ	/;  USER IO CHANNEL /
	SKIPGE	TAC,AC2-17(P)
	JRST	ANY7A
	PUSHJ	P,DISLOC
	PUSHJ	P,DISCRLF
	JRST	ANY7B

ANY7A:	PUSHJ	P,DISMES
	ASCIZ	/ SAVGET
/
ANY7B:	POPACS
	JRST	ANY2

ANYHCC:	PUSHACS	
	PUSHJ	P,DISDAT
	PUSHJ	P,DISJOB
	PUSHJ	P,DISMES
	ASCIZ	/ JOBHCU CLOBBERED AT ANYACT. JOBHCU = /
	MOVE	TAC,AC2-17(P)
	PUSHJ	P,DISOCT
	PUSHJ	P,DISCRLF
	POPACS
	XCTR	XW,[SETZM JOBHCU]	;SET ONLY USER CHANNEL 0 IN USE.
	XCTR	XW,[SETZM JOBJDA]	;CLEAR USER CHANNEL 0.
	JRST	CPOPJ1			;FAKE SUCCESS RETURN.
SUBTTL	CORE0

COMMENT $

CORE0 is called by the CORE command or for the initial core
assignment of just a job data area for the RUN command, etc.  Devices
may be active, or the job may have no previous core.  When CORE0 is
called for a job that either has no core or is swapped out, the new
"core" assigned will be swapped out.  If IMGOUT is zero (i.e., we are
assigning new core where there was none before) then the swapper will
clear the job data area (CLRJB1) and clear JOBSA.

CALL:	MOVE	TAC,HIGHEST LEGAL ADDRESSABLE LOC. DESIRED
	MOVE	J,JOB NUMBER
	PUSHJ	P,CORE0
	<ERROR>	;EITHER JOB HAS ACTIVE IO, OR NOT ENOUGH CORE
	<OK>

The job may be moved if necessary to satisfy this request.  The new
core assignment is set in PROG on either return (zero means none
assigned).  The success return will be given even if the "core"
assigned is swapped out.  CORE0 does not wait for the core to be
swapped in.

$



↑CORE0:	CAML	TAC,SWAPLIMIT	;IS HE BEING TOO GREEDY.
	POPJ	P,		;FLUSH THE GREEDY BASTARD
	SKIPE	JBTPAG(J)	;SKIP IF THERE IS NO CORE ASSIGNED IN CORE
	JRST	CORE0A		;JOB HAS CORE IN CORE.
	MOVSI	TAC1,SWP	;IS THERE CORE ON THE DISK?
	TDNN	TAC1,JBTSTS(J)
	DPB	TAC1,IMGOUT	;NO CORE ON THE DISK.  ZERO IMGOUT.
	IORM	TAC1,JBTSTS(J)	;MARK CORE AS SWAPPED OUT (IF ZERO CORE)
	JUMPE	TAC,CORE0B	;JUMP IF REQUESTING NO CORE.
	IORI	TAC,777
	ADDI	TAC,1
	LSH	TAC,-=9		;CONVERT CORE REQUEST TO PAGE COUNT
	JRST	CORE0K

;ENTER AT CORE0K TO ADJUST CORE IMAGE SIZE WHILE JOB IS ON DISK.
;(THIS IS CALLED FROM THE COMMAND DECODER TO SHRINK BEFORE COMAND)

CORE0B:	ANDCAM	TAC1,JBTSTS(J)	;REQUESTING NO CORE.  CLEAR "CORE ON DISK" BIT.
↑CORE0K:
PRINTX HERE'S AN EVEN-PAGE CROCK!
	TRNE	TAC,1
	ADDI	TAC,1
	DPB	TAC,IMGIN	;STORE NEW CORE IMAGE BLOCK SIZE (IN PAGES)

IFN FTSTAT,<	PUSH	P,TAC
		LSH	TAC,6
		TRO	TAC,CSZSTA
		PUSHJ	P,STAPUT
		POP	P,TAC	>;FTSTAT

	SETZM	SWPCNT		;WAKE UP SWAPPER NEXT TICK
	LDB	TAC1,IMGOUT	;SIZE ON DISC (PAGES)
	CAMGE	TAC,TAC1	;IS NEW SIZE LESS THAN AMOUNT ON DISC?
	DPB	TAC,IMGOUT	;YES, REPLACE DISC SIZE
	JRST	CPOPJ1		;GIVE SKIP RETURN
;CORE1, SHFCOR

COMMENT $

CORE1 is called from UCORE (CORE, CORE2, REMAP UUOs, and BUFCLC), and
from RUNCOR when the RUN command reassigns the proper amount of core
after reading the directory to see how big the file is.  The job must
already have core assigned and no active devices.  Old core is
returned to the system and CORGET is called to assign new core.

$


CORE0A:	PUSHJ	P,ANYACT	;(HERE FROM CORE0)  ANY ACTIVE DEVICE?
	POPJ	P,		;YES, CANNOT ASSIGN CORE
↑CORE1:	ANDI	TAC,-1		;LOOK AT RIGHT HALF ONLY.
	CAMGE	TAC,CORMAX	;IS THIS TOO MUCH?
	CAML	TAC,SWAPLIMIT	;CAN HE HAVE THIS MUCH?
	POPJ	P,		;NO
	MOVE	LOC,JBTSTS(J)
	TRNE	LOC,JLOCK
	PUSHJ	P,UNLOCK	;RELEASE LOCKED CORE
	ADDI	TAC,1		;CONVERT REQUEST TO WORD COUNT
	LSH	TAC,-=9		;CONVERT REQUEST TO PAGES
CORE1A:	HRRZ	LOC,JBTPAG(J)	;FIRST PAGE OF OLD ASSIGNMENT
	HLRZ	BLK,JBTPAG(J)	;NUMBER OF PAGES OF OLD ASSIGNMENT.
	MOVE	PROG,JBTPAG(J)	;PROG←OLD CORE ASSIGNMENT
	JUMPE	TAC,CORG2	;JUMP IF DESIRED ASSIGNMENT IS ZERO.
	CAIN	TAC,(BLK)	;IF HE IS THE SAME
	JRST	DIDLEA		; LEAVE NOW
	CAILE	TAC,(BLK)	;IF HE IS EXPANDING
	JRST	CORG2		; LET HIM EXPAND

IFN FTHPSG,<	CAIL	LOC,1000
		JRST	CORSHC	;SHRINK IN HIGH CORE >

	ADDI	LOC,(TAC)	;LOC←FIRST PAGE TO FREE
	HLRZ	BLK,JBTPAG(J)
	SUBI	BLK,(TAC)	;BLK←NUMBER OF PAGES TO GIVE BACK

IFN FTPAGER,<	PUSHJ P,ZMAPL	;CLEAR OUT THESE PAGE MAP ENTRIES
		 SETZM (TAC1)	>;FTPAGER

	MOVEI	UCHN,0
	PUSHJ	P,CORSTG	
	HRLI	PROG,(TAC)	;PROG←NUMBER OF PAGES,,FIRST PAGE
	JRST	DIDLEA

SHFCOR:	PUSHJ	P,ANYACT	;ENTER HERE FROM THE SHUFFLER.
	POPJ	P,
	PUSHJ	P,APRMAP	;SETUP MAP FOR THIS USER. CALLER SHOULD SAVE MAP.
	HRRZ	LOC,JBTPAG(J)
	HLRZ	BLK,JBTPAG(J)
	MOVE	TAC,BLK		;DESIRED NEW CORE SIZE IS THE SAME AS WE HAD.
CORG2:	MOVEI	UCHN,0		;MARK OLD CORE ASSIGNMENT AS FREE.

IFN FTHPSG,<	CAIL	LOC,1000	;SKIP IF OLD CORE WAS LOW CORE
		JRST	CORGFH		;THINK ABOUT HIGH CORE.>

IFN FTPAGER,<	PUSHJ P,LMAPL	;LOOP THROUGH PAGE MAP FOR LOWER'S PAGES
		 SETZM (TAC1)	; CLEARING THE ENTRIES >;FTPAGER

	PUSHJ	P,CORSTG	;RETURN OLD CORE TO FREE POOL
	JRST	CORG1		;NOW, TRY TO ASSIGN NEW CORE.

IFN FTHPSG,<			;HERE IF OLD CORE WAS ASSIGNED IN HIGH CORE.
CORGFH:	JUMPN	TAC,CORXHC	;JUMP IF EXPANDING HIGH CORE.
	PUSH	P,LOC		;CORE 0 ON HIGH CORE SEGMENT
	PUSH	P,AC3
	MOVE	AC3,JBTMAP(J)
	LSH	AC3,=9
	HRLI	AC3,-1000
CORHF1:	SKIPN	TAC,(AC3)	;SKIP IF PAGE EXISTS.
	JRST	CORHF2
	HRRZ	TAC,TAC		;PAGE NUMBER OF THAT PAGE.
	PUSHJ	P,CORGB1
	LDB	UCHN,TAC
	CAIE	UCHN,(J)
	HALT	.+1
	MOVEI	UCHN,0
	DPB	UCHN,TAC	;ZERO THE CORTAB ENTRY
	AOS	CORHTL		;COUNT A PAGE FREE
	SETZM	(AC3)		;FLUSH JBTMAP ENTRY.
CORHF2:	AOBJN	AC3,CORHF1
	POP	P,AC3
	POP	P,LOC

	PUSHJ	P,HCBUG

	MOVEI	TAC,0
	JRST	CORG1

CORXHC:	MOVEI	AC3,(TAC)	;HERE TO EXPAND HIGH CORE
	SUBI	AC3,(BLK)	;AC3←NUMBER OF PAGES ADDITIONAL THAT ARE NEEDED.
	CAMG	AC3,CORHTL
	JRST	CORXH1		;THERE'S ROOM ENOUGH IN HIGH CORE FOR THIS STUFF.
	PUSH	P,TAC		;SAVE DESIRED SIZE.
	PUSHJ	P,HTLMOV	;MOVE CORE FROM HIGH TO LOW
	POP	P,TAC
	JRST	CORE1A		;ONE MORE TIME. 

CORXH1:	PUSH	P,TAC		;SAVE TOTAL COUNT TOO.
	PUSH	P,AC3		;SAVE THE COUNT OF ADDITIONAL PAGES.
	MOVE	LOC,JBTMAP(J)	;ADDRESS OF JBTMAP
	LSH	LOC,=9
	HLL	LOC,(LOC)	;USE SAME LEFT HALF BITS IN NEW ENTRIES
	ADDI	LOC,(BLK)	;LOC←LH OF PAGE TABLE,,ADDRESS OF FIRST EMPTY ENTRY
	MOVE	BLK,FHUPAG
CORXH2:	CAML	BLK,LHUPAG
	HALT	.		;ERROR.
	MOVEI	TAC,(BLK)
	PUSHJ	P,CORGB1
	LDB	TAC1,TAC
	JUMPN	TAC1,CORXH3	;JUMP IF THIS BLOCK IS IN USE.
	DPB	J,TAC
	SOS	CORHTL
	MOVEM	BLK,(LOC)
	HLLM	LOC,(LOC)
	ADDI	LOC,1
	SOSLE	(P)
CORXH3:	AOJA	BLK,CORXH2
	SUB	P,[1,,1]
	POP	P,TAC
	MOVSI	PROG,(TAC)
	HRR	PROG,JBTPAG(J)
	
	PUSHJ	P,HCBUG

	JRST	DIDLE

CORSHC:	MOVE	AC3,JBTMAP(J)	;HERE TO SHRINK IN HIGH CORE.
	LSH	AC3,=9
	HRLI	AC3,-1000(TAC)
	ADDI	AC3,(TAC)	;AOBJN POINTER TO JBTMAP ENTRIES TO THROW OUT
	HRLI	PROG,(TAC)
CORSC1:	SKIPN	TAC,(AC3)	;IS THERE CORE HERE?
	JRST	CORSC2		;NO.
	HRRZ	TAC,TAC
	PUSHJ	P,CORGB1
	LDB	TAC1,TAC
	CAIE	TAC1,(J)
	HALT	.+1
	SETZB	TAC1,(AC3)
	DPB	TAC1,TAC
	AOS	CORHTL
CORSC2:	AOBJN	AC3,CORSC1
	
	PUSHJ	P,HCBUG

	JRST	DIDLE
>;FTHPSG
;CORGET, BAKOLD, CORG1

COMMENT $

CORGET assigns core.  Called when a job has no core assigned (from
the swapper, or after CORE1 gave the old core away).  If new core is
assigned, it will be in the lowest position possible.  If the new
request cannot be granted, the old assignment is restored and the job
is marked for swapout by calling XPAND (see BAKOLD).

$

↑CORGET:CAMGE	TAC,CORMAX	;IS THIS TOO MUCH?
	CAML	TAC,SWAPLIMIT	;CAN HE HAVE THIS MUCH?
	POPJ	P,
	ADDI	TAC,1
	LSH	TAC,-=9		;CONVERT REQUEST TO PAGE COUNT.
CORG1:	SETZB	LOC,PROG	;SET NEW ASSIGNMENT AND DISTANCE MOVED TO 0
	AOS	NCORCALLS
	JUMPE	TAC,DIDLE2	;EXIT IF ZERO IS CORE BEING REQUESTED
	CAME	J,SHFWAT	;WAITING FOR CURRENT JOB?
	SKIPN	SHFWAT		;IF SHUFFLING, PRETEND NOT AVAIL.
	PUSHJ	P,HOLSRC	;NO, SEARCH FOR HOLE BIG ENOUGH
	SKIPA	UCHN,JBTSTS(J)	;NO HOLE AVAILABLE.  REASSIGN THE OLD CORE.  SKIP.
	JRST	CORGT1		;NEW ASSIGNMENT WAS MADE.
	TLNE	UCHN,SWP	;SKIP UNLESS CORGET WAS CALLED FROM SWAPPER.
	JRST	DIDLE4		;  SWAPPER GETS FAILURE (NO SKIP) RETURN
	PUSHJ	P,XPAND		;MARK THIS JOB AS EXPANDING.  WILL BE SWAPPED OUT.
	HLRZ	TAC,JBTPAG(J)	;REASSIGN OLD CORE.
	HRRZ	LOC,JBTPAG(J)
CORGT1:	MOVEI	PROG,(LOC)	;FIRST PAGE OF NEW ASSIGNMENT
	HRLI	PROG,(TAC)	;NUMBER OF PAGES IN NEW ASSIGNMENT
	MOVEI	BLK,(TAC)	;NUMBER OF PAGES IN NEW ASSIGNMENT
	MOVE	UCHN,J		;SET USE BITS IN CORE TABLE

IFN FTPAGER,<	PUSH	P,DDB
		LDB	DDB,[POINT 1,JBTSTS(J),JWPPOS]	;DDB←WRITE PROTECT BIT
		PUSHJ	P,LMAPL		;SETUP PAGE MAP, WITH WRITE PROTECT
		 PUSHJ	 P,STRMAP	;  SET FROM DDB
NOKL10,<	CONO	PAG,3		;CLEAR ARS MAPPING USER PAGES >;NOKL10
IFKL10,<	CONO	KLPAG,@KLPCON	>;IFKL10
		POP	P,DDB		>;FTPAGER

	PUSHJ	P,CORSTG	;FIX CORTAB
	SKIPN	BLK,JBTPAG(J)	;GET OLD CORE ASSIGNMENT
	JRST	DIDLEA		;ON SWAP IN THERE'S NO OLD CORE.
	CAIN	LOC,(BLK)	;IS NEW CORE IN SAME PLACE AS OLD?
	JRST	DIDLE		;YES, DO NOT MOVE IT.
MOVCO1:	HLRZ	TAC1,BLK	;LENGTH OF OLD CORE IN PAGES.
	CAILE	TAC1,(TAC)	;SKIP UNLESS OLD CORE MORE THAN NEW.
	MOVEI	TAC1,(TAC)	;MOVE ONLY THE NEW, SHORTENED, CORE.
	LSH	TAC1,=9		;CONVERT TO WORDS
	ADDM	TAC1,SHFWRD	;INCREMENT TOTAL NO. WORDS SHUFFLED
	MOVEM	BLK,PARBLK	;SAVE THIS FOR PARSER.
	SETZM	JBTPAG(J)
	MOVEM	J,PARSJB	;FOR PARSER, THE JOB BEING SHUFFLED

IFN FTHG,<	PUSH	P,HGCODE
		HGMAC	(30)	>

	MTRON	(MTRSHF)

;RH(BLK)=SOURCE PAGE.  LOC=DESTINATION PAGE, TAC1=NUMBER OF WORDS

IFE FTEXPG,<
	LSH	LOC,=9
	ADD	TAC1,LOC	;ADD IN NEW RELOC = ENDING ADDRESS OF BLT+1
	MOVE	TAC,LOC		;DESTINATION IS THE NEW RELOCATION
	LSH	BLK,=9
	HRL	TAC,BLK		;SOURCE IS THE OLD RELOCATION

↑SHFBLT:BLT	TAC,-1(TAC1)	;LABEL FOR PARSER.

>;IFE FTEXPG

IFN FTEXPG,<
	LSH	TAC1,-=9	;CONVERT WORD COUNT TO PAGES
	MOVEI	LOC,0		;START AT USER ADDRESS 0.
BLTLP:	PUSH	P,TAC1		;SAVE COUNT OF PAGES
	MOVEI	TAC1,SHFEXP
	MOVEI	TAC,(BLK)	;SOURCE PAGE NUMBER
	PUSHJ	P,ADDEMP	;MAP SOURCE PAGE ONTO SHFEXP
	MOVE	TAC,JBTMAP(J)
	LSH	TAC,=9
	ADDI	TAC,(LOC)	;DESTINATION PAGE NUMBER
	MOVE	TAC1,(TAC)
	TLO	TAC1,40000	;MAKE SURE DESTINATION IS WRITEABLE
	MOVEM	TAC1,EXPGT+SHFEXP+1	;MAP DESTINATION PAGE ONTO SHFEXP+1
	MOVE	TAC,[SHFEXP⊗9,,<SHFEXP+1>⊗9]
NOKL10,<CONO	PAG,1			>;NOKL10
IFKL10,<CONO	KLPAG,@KLPCON		>;IFKL10
↑SHFBLT:BLT	TAC,<SHFEXP+1>⊗9+777	;LABEL FOR PARSER
	SETZM	EXPGT+SHFEXP	;DELETE MAP ENTRY FOR SOURCE
	SETZM	EXPGT+SHFEXP+1	;AND FOR DESTINATION.
	POP	P,TAC1		;RESTORE COUNT OF PAGES TO MOVE
	ADDI	LOC,1		;ADVANCE THE (RELATIVE) DESTINATION PAGE NUMBER
	ADDI	BLK,1		;ADVANCE THE (ABSOLUTE) SOURCE PAGE ADDRESS
	SOJG	TAC1,BLTLP
NOKL10,<CONO	PAG,1		>;NOKL10
IFKL10,<CONO	KLPAG,@KLPCON	>;IFKL10
>;IFN FTEXPG

	MTROFF	(MTRSHF)

IFN FTHG,<	POP	P,HGCODE>

	MOVEI	LOC,(PROG)	;LOC←PAGE NUMBER OF NEW ASSIGNMENT - FOR DIDDLE
	MOVE	BLK,JBTPAG(J)	;BLK←OLD ASSIGNMENT - FOR DIDDLE
	JRST	DIDLE		;RECOMPUTE CORE PARAMETERS, SKIP RETURN TO USER
SUBTTL	DIDDLE		;DIDLE, DIDLEA, DIDLE2

COMMENT $
Call DIDLE after allocating new core for a job that had old core
(i.e., after core may have been moved).  Principal calls are (1)
expanding core size for a job, and (2) shuffling a job.
If the shuffled job is the current job, then hardware state needs to be
changed.  DIDLE skip returns.

In the bad old days, the UUO level PDL was in the job data area.  This
required that P in the dump acs, and sometimes the current exec P needed
to be diddled too.  The new system prohibits direct reference to user
core, so all that has been flushed.

Call DIDLEA when core is not actually moved (i.e., shrunk in place,
or new core was allocated by the swapper).  DIDLEA skip returns.
[For segments when we get to DIDLEA for the above two reasons, either
CORE2 is going to call AUPMAP or FININ will call AUPMAP from FINMST]

Call DIDLE2 with PROG, TAC, and LOC all zero, to release all core.  Skips.

Call DIDLE4 to recompute parameters for the swapper (HOLEF, BIGHOL).
DIDLE4 does not skip.

Enter with PROG=new core assignment [JBTPAG format].

$

DIDLE:	MOVE	TAC,JBTSTS(J)
	TLNN	TAC,JSEG		;DID WE MOVE AN UPPER?
	JRST	DIDLE6			;NO.  THIS IS A LOWER

IFN FTPAGER,<	PUSH	P,JBTPAG(J)
		MOVEM	PROG,JBTPAG(J)	;STORE NEW CORE ASSIGNMENT FOR AUPMAP
		CAME	PROG,(P)	;(SKIP IF NOTHING REALLY MOVED)
		PUSHJ	P,AUPMAP	;FIX LOWERS' PAGE MAPS
		POP	P,JBTPAG(J)	>;FTPAGER

IFN FTSTAT,<	CAME	PROG,JBTPAG(J)
		PUSHJ	P,CSTAT	>

	MOVEM	PROG,JBTPAG(J)		;STORE NEW CORE ASSIGNMENT

	PUSH	P,J			;DOES THE CURRENT JOB USE THIS SEGMENT?
	MOVE	J,JOB(PID)
	LDB	TAC,PSEGN
	CAME	TAC,(P)
	JRST	DIDLE5			;CURRENT JOB DOESN'T USE THIS SEGMENT.
	JRST	DIDLE7			;CUREENT JOB USES THIS SEG. CHANGE APRMAP

;ENTER DIDLEA WHEN CORE WASN'T MOVED (SHRINK, OR NEW ASSIGNMENT FOR SWAPIN)
DIDLEA:	MOVE	TAC,JBTSTS(J)
	TLNN	TAC,JSEG		;SKIP IF THIS IS A SEGMENT
DIDLE6:	PUSHJ	P,DIDLEX		;ADJUST JOBREL IN USER'S AREA
DIDLE2:					;ENTER WITH PROG=0 TO RELEASE CORE.

IFN FTSTAT,<	CAME	PROG,JBTPAG(J)
		PUSHJ	P,CSTAT	>

	MOVEM	PROG,JBTPAG(J)		;STORE NEW CORE ASSIGNMENT
	MOVE	TAC,JBTSTS(J)
	TLNN	TAC,JSEG
	CAME	J,JOB(PID)		;IS THIS CURRENT JOB?
	JRST	DIDLE9			;NO, DO NOT ALTER STATE OF MONITOR
	PUSH	P,J

DIDLE7:

IFE FTPAGER,<	PUSHJ	P,GETPR		;GET JOB'S PROT-RELOC IN TAC
		DATAO	APR,TAC		>;IFE FTPAGER

IFN FTPAGER,<				;CLEAR ARS MAPPING USER PAGES
NOKL10,<	CONO	PAG,3		>;NOKL10
IFKL10,<	CONO	KLPAG,@KLPCON	>;IFKL10
					>;FTPAGER

DIDLE5:	POP	P,J
DIDLE9:	AOS	(P)		;SET SKIP RETURN.  NOTE DIDLE4 DOESN'T SKIP ANYMORE

IFKL10,<
	PSYNC	CSHCSC			;NOTE THAT THIS ROUTINE RUNS CH7/UUO ONLY
	MOVSI	TAC,CSHON		;LEAVE ONLY THE REASON BITS.  ALLOW CSHSET
	ANDCAM	TAC,JBTCSH(J)		;TO TURN THE CACHE ON IF IT'S SUPPOSED TO.
	XSYNC	CSHCSC
	PUSHJ	P,CSHSET
>;IFKL10

DIDLE4:	SETZB	TAC,HOLEF	;CLEAR HOLE FLAG
	PUSHJ	P,HOLSRC	;IS THERE A NON-ZERO HOLE?
	JRST	COROK		;NO
	ADDI	LOC,(BLK)	;YES.  FORM PAGE NUMBER ABOVE END OF HOLE
	CAMGE	LOC,MEMPAG	;SKIP IF HOLE IS AT THE TOP OF MEMORY.
	MOVEM	LOC,HOLEF	;SET HOLEF WITH PAGE NUMBER OF JOB ABOVE HOLE
COROK:	MOVEI	TAC,-1		;FIND BIGGEST HOLE (ASK FOR TOO MUCH!)
	PUSHJ	P,HOLSRC
	JFCL
	MOVEM	AC2,BIGHOLE	;SIZE OF BIGGEST HOLE (IN PAGES)
IFN FTCORBUG,<	PUSHJ	P,CORTCK >	;CHECK FOR CORTAB - JBTADR CONSISTENCY
	POPJ	P,		;(THIS WILL SKIP, EXCEPTING CALLS TO DIDLE4)


DIDLEX:	PUSHJ	P,MAPSET
	HLRZ	TAC,PROG		;STORE JOBREL OF NEW CORE ASSIGNMENT
	LSH	TAC,=9
	SUBI	TAC,1
	XCTR	XW,[HRRZM TAC,JOBREL]	;ALWAYS SET JOB DATA AREA W/PROTECTION
	POPJ P,				;RETURN FROM DIDLEX (THROUGH MAPSET)

IFN FTSTAT,<
;CALL WITH PROG=NEW CORE, JBTPAG(J)=OLD CORE
CSTAT:	MOVE	TAC,JBTSTS(J)
	TLNE	TAC,SWP		;IF SWAPPER,
	JRST	CSTAT0		;THEN IS ONLY POSITION CHANGE
	MOVE	TAC,PROG
	XOR	TAC,JBTPAG(J)
	TLNN	TAC,-1		;CHANGE IN SIZE?
	JRST	CSTAT1		;NO CHANGE IN SIZE.
	HLRZ	TAC,PROG	;TAC←NEW SIZE
	LSH	TAC,6
	IORI	TAC,CSZSTA
	PUSHJ	P,STAPUT	;SEND SIZE
CSTAT1:	JUMPE	PROG,CPOPJ	;REPORT ONLY PROT IF CORE 0
	MOVE	TAC,PROG
	XOR	TAC,JBTPAG(J)	;ANY POSITION CHANGE?
	TRNN	TAC,-1
	POPJ	P,
CSTAT0:	MOVEI	TAC,CPSSTA	;REPORT POSITION CHANGE
	PUSHJ	P,STAPUT
	HRRZ	TAC,PROG
	JRST	STAPTT		;REPORT NEW POSITION.
>;IFN FTSTAT
SUBTTL	HOLSRC	
;ROUTINE TO FIND HOLE BIG ENOUGH FOR REQUEST
;CALL:	MOVE	TAC,<NUMBER OF PAGES WANTED>
;	PUSHJ	P,HOLSRC
;	RETURN1	;NO HOLES BIG ENOUGH.  AC2=SIZE OF LARGEST HOLE (IN PAGES)
;	RETURN2	;BLK SET TO NUMBER OF PAGES IN THE HOLE
;		;LOC SET TO FIRST PAGE IN THE HOLE
;USES TAC1


HOLSRC:	SETZB	AC2,CORTLX	;LARGEST HOLE SIZE = 0.  TOTAL FREE = 0
	MOVE	LOC,LOKPAG	;START SCAN AT BOTTOM OF UNLOCKED CORE.
CORHOL:	TDZA	BLK,BLK		;LOOK FOR A HOLE.  INITIAL SIZE IS ZERO. SKIP
CORHO0:	ADDI	BLK,1		;INCREMENT SIZE OF PRESENT HOLE
CORHO1:	CAML	LOC,MEMPAG	;ARE WE WITHIN LOW CORE?
	AOJA	LOC,CORHO2	;NO.  SIMULATE END OF THE PRESENT HOLE.

IFE FTPAGER,<	PUSH	P,TAC
		PUSHJ	P,CORGBP
		LDB	TAC1,TAC
		POP	P,TAC	>;IFE FTPAGER

IFN FTPAGER,<	LDB	TAC1,COREP	;(INDEX BY LOC)	>;IFN FTPAGER

	ADDI	LOC,1		;ADVANCE TO NEXT PAGE.
	JUMPE	TAC1,CORHO0	;JUMP IF THIS PAGE IS FREE
	JUMPE 	BLK,CORHO1	;PAGE IN USE.  JUMP IF WE'RE NOT AT END OF A HOLE
CORHO3:	CAMLE	BLK,AC2		;END OF A HOLE. IS THIS ONE THE BIGGEST SO FAR?
	MOVE	AC2,BLK		;YES, SAVE IN AC2
	ADDM	BLK,CORTLX
	CAMGE	BLK,TAC		;IS THIS HOLE BIG ENOUGH FOR THIS REQUEST?
	JRST	CORHOL		;NO, KEEP LOOKING FOR HOLES
	SUBI	LOC,1(BLK)	;YES, SET LOC TO FIRST PAGE IN THE HOLE
	JRST	CPOPJ1

CORHO2:	JUMPN	BLK,CORHO3	;SIMULATE END OF HOLE SEEN
	MOVE	TAC1,CORTLX
	CAMN	TAC1,CORTAL
	POPJ	P,		;NOT INSIDE OF A HOLE.  RETURN NOW.
	PUSHACS
	PUSHJ	P,DISMES
	ASCIZ	/CORTAL INCONSISTENT AT HOLSRC
/
	PUSHJ	P,DISFLU
	POPACS
	PUSHJ	P,WDDTCAL
	MOVEM	TAC1,CORTLX
	POPJ	P,
;CORCHK AND CORTCK  -- CHECK CORTAL AGAINST CORTAB AND CHECK CORTAB AGAINST WORLD
IFN FTCORBUG,<

CORCHK:	PUSH	P,TAC		;MAKE SURE CORTAB AND CORTAL ARE CONSISTENT
	PUSH	P,AC2
	PUSH	P,AC1
	PUSH	P,TAC1
	PUSH	P,LOC
	MOVE	LOC,LOKPAG
	MOVEI	AC2,0		;COUNT FREE PAGES ABOVE LOKTOP
CORCH1:	CAML	LOC,MEMPAG
	JRST	CRCH1A
	PUSHJ	P,CORGBP
	ADDI	LOC,1
	LDB	TAC,TAC
	JUMPN	TAC,CORCH1
	AOJA	AC2,CORCH1	;COUNT A FREE PAGE

CRCH1A:	CAMN	AC2,CORTAL
	JRST	CORCH8		;RIGHT ANSWER
	PUSHACS
	PUSHJ	P,DISMES
	ASCIZ	/CORTAL = /
	MOVE	TAC,CORTAL
	PUSHJ	P,DISLOC
	PUSHJ	P,DISMES
	ASCIZ	/,SHOULD BE = /
	MOVE	TAC,AC2-17(P)
	PUSHJ	P,DISLOC
	PUSHJ	P,DISMES
	ASCIZ	/;     CALLER'S ADDRESS = /
	HRRZ	TAC,-26(P)
	PUSHJ	P,DISLOC
	PUSHJ	P,DISCRLF
	PUSHJ	P,DISFLU
	PUSHJ	P,WDDTCALL
	POPACS
	MOVEM	AC2,CORTAL

CORCH8:

IFN FTHPSG,<
	MOVE	LOC,FHUPAG
	MOVEI	AC2,0		;COUNT FREE PAGES IN HIGH CORE.
CORC8A:	CAML	LOC,LHUPAG
	JRST	CRCH8B
	LDB	TAC,COREP
	ADDI	LOC,1
	JUMPN	TAC,CORC8A
	AOJA	AC2,CORC8A	;COUNT A FREE PAGE

CRCH8B:	CAMN	AC2,CORHTL
	JRST	CORC8C		;RIGHT ANSWER
	PUSHACS
	PUSHJ	P,DISMES
	ASCIZ	/CORHTL = /
	MOVE	TAC,CORHTL
	PUSHJ	P,DISLOC
	PUSHJ	P,DISMES
	ASCIZ	/,SHOULD BE = /
	MOVE	TAC,AC2-17(P)
	PUSHJ	P,DISLOC
	PUSHJ	P,DISMES
	ASCIZ	/;     CALLER'S ADDRESS = /
	HRRZ	TAC,-26(P)
	PUSHJ	P,DISLOC
	PUSHJ	P,DISCRLF
	PUSHJ	P,DISFLU
	PUSHJ	P,WDDTCALL
	POPACS
	MOVEM	AC2,CORHTL

CORC8C:
>;FTHPSG

	POP	P,LOC
	POP	P,TAC1
	POP	P,AC1
	POP	P,AC2
	POP	P,TAC
	POPJ	P,


CORTCK:	PUSH	P,AC1
	PUSH	P,AC2
	PUSH	P,AC3
	PUSH	P,LOC
	PUSH	P,J
	PUSH	P,TAC
	PUSH	P,TAC1

	MOVE	J,JOBNM1
CORCKL:	MOVE	AC2,JBTSTS(J)
	TLNE	AC2,JNA			;IS THERE A JOB HERE?
	SKIPN	AC2,JBTPAG(J)		;YES.  IS IT INCORE?
	JRST	CORCKN			;NO JOB OR NO CORE
	HRRZ	LOC,AC2			;ADDRESS OF HIS FIRST PAGE
	HLRZ	AC2,AC2			;PAGE COUNT
CORCK1:	PUSHJ	P,CORGBP
	ADDI	LOC,1
	LDB	AC3,TAC
	CAIE	AC3,(J)
	JRST	CORCKC			;CORTAB ISN'T MARKED ACCORING TO THIS JBTPAG
	SOJG	AC2,CORCK1		;DECREMENT COUNT OF JOB'S PAGES
CORCKN:	SOJG	J,CORCKL		;LOOK THRU ALL JOBS

	MOVE	LOC,SYSPAG		;FIRST PAGE OF USER CORE.
CORCK0:	CAML	LOC,MEMPAG		;SKIP UNLESS WE'RE AT THE END
	JRST	CORCKZ			;END. TEST OK.
	PUSHJ	P,CORGBP		;LOOK AT ALL USER STG CORTAB ENTRIES
	LDB	J,TAC
	JUMPE	J,[AOJA LOC,CORCK0]	;HOLE. ADVANCE TO NEXT PAGE
	CAMLE	J,JOBNM1
	JRST	CORCKD			;ILLEGAL BYTE IN CORTAB
	MOVE	AC1,JBTPAG(J)
	CAIE	LOC,(AC1)
	JRST	CORCKE			;NOT FIRST BLOCK OF THIS JOB!
	HLRZ	AC2,AC1			;AC2←PAGE COUNT OF THIS JOB.
	ADDI	LOC,(AC2)		;ADVANCE PAST THIS JOB.
	JRST	CORCK0			;LOOK FOR OTHR THINGS.

CORCKZ:	POP P,TAC1
	POP P,TAC
	POP P,J
	POP P,LOC
	POP P,AC3
	POP P,AC2
	POP P,AC1
	JRST CORCHK		;NOW CHECK CORTAL

CORCKC:	JSP	TAC1,CORCKX	;BLOCK CLAIMED IN JBTPAG BUT NOT IN CORTAB
CORCKD:	JSP	TAC1,CORCKX	;ILLEGAL VALUE OF CORTAB BYTE
CORCKE:	JSP	TAC1,CORCKX	;BLOCK WASN'T FIRST BLOCK OF A JOB

CORCKX:	PUSHACS
	PUSHJ	P,DISMES
	ASCIZ	/LOSSAGE AT CORCHK -- GET A WIZARD.  THE WINNING ENTRY IS /
	HRRZ	TAC,TAC1-17(P)
	SUBI	TAC,CORCKC+1
	PUSHJ	P,DISOCT
	PUSHJ	P,DISCRLF
	PUSHJ	P,DISFLU
	PUSHJ	P,DDTCAL
	POPACS
	JRST	CORCKZ
>;IFN FTCORBUG
SUBTTL	CORSTG - SET AND CLEAR CORE USE TABLE ;CORGBP,CORSGT

LOSYS

;CALL:	MOVE	UCHN,<JOB NUMBER, OR OTHER CODE>	;TO SET TABLE
;	MOVEI	UCHN,0					;TO CLEAR TABLE
;	MOVE	BLK,<NUMBER OF PAGES TO AFFECT>
;	MOVE	LOC,<NUMBER OF FIRST AFFECTED PAGE>
;	PUSHJ	P,CORSTG
;	<RETURNS WITH BLK=0>


↑CORSTG:			;THE EXTERNAL CALLS ARE FROM REMAP IN UUOCON
	PUSH	P,TAC		;SAVE HIGHEST LOC. BEING REQUESTED
	PUSH	P,LOC		;SAVE STARTING ADDRESS
	JUMPE	UCHN,.+2	;UPDATE NO OF FREE BLOCKS
	MOVNI	BLK,(BLK)	;DECREASE IF SETTING BITS
	CAML	LOC,LOKPAG	;IF THIS IS A CALL IN LOCKED CORE, LOCK AND
				;UNLOCK ARE RESPONSIBLE FOR DIDDLING CORTAL - REG
	ADDM	BLK,CORTAL	;INCREASE IF CLEARING,DECREASE IF SETTING BITS
	MOVM	BLK,BLK		;GET MAG. OF NO. OF BLOCKS INVOLVED
CORST1:

IFE FTPAGER,<	PUSHJ	P,CORGBP	;MAKE A BYTE POINTER >
IFN FTPAGER,<	MOVE	TAC,COREP	;GET A BYTE POINTER (INDEX OF LOC)>

	LDB	TAC1,TAC	;GET OLD BYTE
	JUMPE	UCHN,CORST9	;LOOK FOR CONFLICTS, JUMP IF CLEARING
	JUMPN	TAC1,CORST2	;SETTING, JUMP IF ALREADY SET (ERROR)
	JRST	CORSTD		;SETTING AND NOT ALREADY SET (O.K.)

CORST9:	JUMPN	TAC1,CORSTD	;CLEARING, JUMP IF SET (O.K.)
CORST2:	PUSHACS			;LOSER.
	PUSHJ	P,DISDATE
	PUSHJ	P,DISMES
	ASCIZ	/CORTAB LOSES AT CORSTG. OLD CLAIM= /
	MOVE	TAC,TAC1-17(P)	;GET THE ARGUMENT
	PUSHJ	P,DISDCP	;TYPE DECIMAL WITH PERIOD
	PUSHJ	P,DISMES
	ASCIZ	/  NEW CLAIM = /
	MOVE	TAC,UCHN-17(P)	;GET NEW CLAIM
	PUSHJ	P,DISDCP	;TYPE DECIMAL W/PERIOD
	PUSHJ	P,DISCRLF
	POPACS
CORSTD:	DPB	UCHN,TAC	;STORE NEW CORE USE BITS.
	ADDI	LOC,1		;ADVANCE TO NEXT PAGE
	SOJG	BLK,CORST1
IFN FTCORBUG,<	PUSHJ	P,CORCHK  >	;MAKE SURE CORTAB AND CORTAL ARE RIGHT
	POP	P,LOC
	JRST	TPOPJ		;RESTORE TAC, AND POPJ
	


IFE FTPAGER,<
COREP:	POINT	9,CORTAB,8
	POINT	9,CORTAB,17
	POINT	9,CORTAB,26
	POINT	9,CORTAB,35

;CALL WITH LOC=PAGE NUMBER.  RETURNS TAC=BYTE POINTER FOR LDB/DPB.  CLOBBERS TAC1
↑CORGBP:			;MAKE A BYTE POINTER TO CORTAB (PARSER CALLS THIS)
	MOVE	TAC,LOC		;ADDRESS OF FIRST BLOCK
CORGB1:	IDIVI	TAC,4		;ENTER HERE WITH TAC SET UP.
	ADD	TAC,COREP(TAC1)	;FORM BYTE POINTER
	POPJ	P,

>;IFE FTPAGER

IFN FTPAGER,<
COREP:	POINT	9,CORTAB(LOC),26	;CORTAB IS REALLY THE CST

↑CORGBP:MOVEI	TAC,(LOC)
CORGB1:	ADD	TAC,COREP
	TLZ	TAC,17			;FLUSH INDEX FIELD
	POPJ	P,
>;IFN FTPAGER

;CORSGT - COMPUTE SIZE (IN WORDS) OF GIVEN JOB.
;CALL:	MOVE	TAC1,<JOB NUMBER>
;	PUSHJ	P,CORSGT		;CHANGES ONLY TAC1
;	<RETURNS TAC1=CORE SIZE OF JOB>

↑CORSGT:PUSH	P,TAC			;SAVE TAC
	MOVE	TAC,JBTSTS(TAC1)	;GET JOB STATUS
	TLNN	TAC,SWP			;SKIP IF ON DISK,
	JRST	CORSG1			;HE'S IN CORE.
	PUSH	P,J
	MOVEI	J,(TAC1)
	LDB	TAC1,IMGIN
	POP	P,J
	LSH	TAC1,=9			;SHIFT TO MAKE WORDS.
	JRST	TPOPJ			;RESTORE TAC AND RETURN.

CORSG1:	HLRZ	TAC1,JBTPAG(TAC1)
	LSH	TAC1,=9
	JRST	TPOPJ
SUBTTL	GETPR	GET A JOB'S PROTECTION-RELOCATION


↑GETPR:	PUSH	P,DAT		;SAVE SOME ACCUMULATORS
	PUSH	P,TAC1
	SKIPN	TAC,J		;FOR JOB 0,
	JRST	GETPR1		;WE SUPPLY A ZERO FOR LASTPR AND FOR DATAO APR,
	MOVE	TAC,JBTPAG(J)	;START WITH THE MAIN PART
	LSH	TAC,=9		;SHIFT TO FORM RELOCATION OF LOWER
	SUB	TAC,[1,,0]	;CORRECT THE PROTECTION
	ANDCM	TAC,[1777,,1777]
	LDB	DAT,PSEGN
	JUMPE	DAT,GETPR4	;IF NO UPPER SEGMENT, WE ARE DONE
	MOVE	TAC1,JBTSTS(DAT);HE HAS AN UPPER, IS IT WRITE-PROTECTED?
	TLNE	TAC1,JWP
	TLO	TAC,1		;YES, SET WRITE-PROTECT BIT
	SKIPN	TAC1,JBTPAG(DAT);PROT,,RELOC OF UPPER
	JRST	GETPR1		;UPPER NOT IN CORE
	LSH	TAC1,=9
	SUB	TAC1,[1,,0]
GETPR5:	HLRZ	DAT,JBTPAG(J)	;PROT OF LOWER
	LSH	DAT,=9
	SUBI	DAT,1
	CAIGE	DAT,400000	;SKIP IF LOWER IS BIGGER THAN 128K
	JRST	GETPR3		;LOWER LE 128K, UPPER STARTS AT 400000
	SUBI	TAC1,(DAT)		;FUDGE RELOCATION BY RIGHT AMOUNT
	HRLZ	DAT,DAT		;PROT OF LOWER + SIZE OF UPPER GIVES
	ADD	TAC1,DAT	; PROT OF UPPER
	JRST	GETPR2

GETPR3:	TRC	TAC1,400000	;REL OF UPPER (FROM JBTADR) CORRESP TO 400000
GETPR2:	TLO	TAC1,400000
	LSH	TAC1,-9
	AND	TAC1,[776,,776]
	IOR	TAC,TAC1	;MERGE TWO RELOCATIONS
GETPR1:	POP	P,TAC1
	POP	P,DAT

IFE FTPAGER,<	MOVEM TAC,LASTPR(PID)	>;NOT FTPAGER - SAVE LAST PROT-RELOC ISSUED

	POPJ	P,

GETPR4:	SKIPN	TAC1,JBTPR2(J)	;IS DOING PEEK-POKE STUFF?
	JRST	GETPR1		;NO
	TRNE	TAC1,4		;IS IT GETHI HACK
	JRST	GETPR1		;YES.  WE ARE DONE (GETHI USES MAP, NOT PROT-REL)
	TLNE	TAC1,1		;IS IT TO BE WRITE PROTECTED?
	TLO	TAC,1		;YES
	TRZN	TAC1,1		;IS IT TO BE RELATIVE TO HIS CORE IMAGE?
	JRST	GETPR5		;NO. 
	PUSH	P,TAC		;YES, CHECK TOP OF HIS CORE IMAGE
	HLRZ	TAC,TAC1	;PROTECTION HE IS REQUESTING
	IORI	TAC,1777	;MAKE IT HONEST
	HLRZ	DAT,JBTPAG(J)	;HIS JOB'S PROTECTION
	LSH	DAT,=9
	SUBI	DAT,1(TAC1)	;HOW FAR FROM NEW RELOCATION TO TOP OF CORE IMAGE.
	JUMPL	DAT,GETPR6	;NOT IN HIS CORE, HE DOESN'T GET TO HAVE AN UPPER
	CAMLE	DAT,TAC		;IS HE REQUESTING TO MUCH?
	MOVE	DAT,TAC		;NO, USE WHAT HE GAVE US
	POP	P,TAC		;GET BACK LOWERS PROT. RELOC.
	HRL	TAC1,DAT	;SET NEW PROT. FOR PR2
	ADDI	TAC1,(TAC)	;AND RELOCATE IT
	JRST	GETPR5		;AND NOW IT LOOKS LIKE AN UPPER

GETPR6:	POP	P,TAC
	TLZ	TAC,1
	JRST	GETPR1
SUBTTL	RELOCA

HISYS

;THIS HERE IS A ROUTINE TO ADDRESS CHECK AND RELOCATE
;A USER ADDRESS. IT MAKES USE OF UPPER SEGMENTS AND
;THE PEEK-POKE FEATURE (JBTPR2).
;CALLING:
;	MOVE J,<NUMBER OF JOB IN QUESTION>
;	MOVE TAC1,<ADDRESS TO CHECK AND RELOCATE>
;	PUSHJ P,RELOCA
;	<ILLEGAL ADDRESS>
;	<LEGAL ADDRESS>
;UPON SUCCESS RETURN TAC1 CONTAINS THE ABSOLUTE ADDRESS
;THE SIGN BIT IS SET IF THIS ADDRESS IS WRITE PROTECTED
;FROM THE USER (THIS INCLUDES THE PROTECTED PART FROM 0-JOBPFI).
;AC1 IS NOW SET-UP FOR A CALL ON RELOCB.


↑↑RELOCA:
	HRRZ	TAC1,TAC1	;CLEAR CONFUSING BITS!
	PUSH	P,TAC		;SAVE AN AC
	MOVEI	TAC,JOBPFI	;USER'S LOWEST LEGAL IO ADDRESS.
	HLL	TAC,UUOPC(J)	;USER OR EXEC OPERATION?
	TLNN	TAC,USRMOD	;SKIP IF USER OP
	HRRI	TAC,JOBSAV	;MONITOR GETS TO DO IO AT LOWER ADDRESSES.
	CAIGE	TAC1,(TAC)	;IS THIS ADDRESS BELOW PROTECTED PART?
	TLO	TAC1,400000	;SET WRITE PROTECTED ACCESS
	HLRZ	TAC,JBTPAG(J)	;GET SIZE OF LOWER
	LSH	TAC,=9
	CAIGE	TAC,(TAC1)	;IS IT OUTSIDE LOWER?
	JRST	RELOC1		;YES, THIS IS HARDER
	HRRZ	AC1,JBTPAG(J)	;FIRST PAGE NUMBER
	LSH	AC1,=9		;RELOCATION VALUE
	ADD	TAC1,AC1	;RELOCATE. (POSSIBLE DATA IN LH OF TAC)
	MOVEI	AC1,JBTPAG(J)	;POINT TO THE RELOCATION WORD WE USED.
	JRST	TPOPJ1		;PUT BACK TAC AND SKIP

RELOC1:	LDB	AC1,PSEGN	;CHECK FOR UPPER SEGMENT
	PUSH	P,DAT		;SAVE ANOTHER AC.
	JUMPE	AC1,RELOC2	;NONE, CHECK PEEK-POKE
	MOVSI	TAC,JWP		;CHECK WRITE PROTECT
	TDNE	TAC,JBTSTS(AC1)
	TLO	TAC1,400000	;WRITE PROTECTED
	HLRZ	DAT,JBTPAG(AC1)	;NUMBER OF PAGES IN UPPER.
	LSH	DAT,=9		;NUMBER OF WORDS IN UPPER.
	HLRZ	TAC,JBTPAG(J)	;NUMBER OF PAGES IN THE LOWER
	CAIGE	TAC,400		;SKIP IF LOWER IS 256 PAGES OR LARGER
	MOVEI	TAC,400		;UPPER STARTS AT PAGE 400
	LSH	TAC,=9		;UPPER'S STARTING WORD ADDRESS.
	SUB	TAC1,TAC	;ADJUST REFERENCE - RELATIVE ADDRESS IN THE UPPER.
	TLNE	TAC1,377777	;UNDERFLOW?
	JRST	RELOC4		;YES, BETWEEN UPPER AND LOWER!
	CAIG	DAT,(TAC1)	;TOO BIG?
	JRST	RELOC4		;TOO BIG.  AVOID SKIP RETURN
	HRRZ	TAC,JBTPAG(AC1)
	LSH	TAC,=9
	ADD	TAC1,TAC
	MOVEI	AC1,JBTPAG(AC1)	;POINT TO THE RELOCATION WORD WE USED.
	AOS	-2(P)		;NEED TO RESTORE DAT, TAC, AND SKIP.
RELOC4:	POP	P,DAT
	JRST	TPOPJ		;LOSE

RELOC2:	SKIPN	AC1,JBTPR2(J)	;IS HE DOING PEEK-POKE
	JRST	RELOC4		;NO. LOSE.  RESTORE DAT, TAC AND RETURN
	TRNE	AC1,4		;IS IT GETHI HACK
	JRST	RELOC4		;YES, LOSE.
	TLOE	AC1,1		;IS HE WRITE PROTECTED(SET BIT FOR COMPARE)
	TLO	TAC1,400000	;YES
	TRZN	AC1,1		;IS THIS A RELATIVE MAPPING?
	JRST	RELC2A		;NOT A RELATIVE UPPER
	HLRZ	TAC,JBTPAG(J)	;SIZE OF LOWER
	LSH	TAC,=9		;SIZE OF LOWER IN WORDS
	SUBI	TAC,(AC1)	;-RELATIVE RELOCATION = MAX. REL. WC OF UPPER
	SOJL	TAC,RELOC4	;ERROR IF REL. PROT. OF UPPER IS TOO SMALL
	HRRZ	DAT,JBTPAG(J)
	LSH	DAT,=9		;STARTING ADDRESS OF LOWER
	ADDI	AC1,(DAT)	;AC1←STARTING ADDRESS OF UPPER
	HRL	AC1,TAC		;AC1←PROT OF UPPER IN LEFT
RELC2A:	MOVEI	DAT,JBTPR2(J)	;POINT TO THE PROT-REL WORD BEING USED.
RELOC3:	HLRZ	TAC,JBTPAG(J)	;NUMBER OF PAGES IN THE LOWER
	CAIGE	TAC,400		;SKIP IF LOWER IS 256 PAGES OR LARGER
	MOVEI	TAC,400		;UPPER STARTS AT PAGE 400
	LSH	TAC,=9		;UPPER'S STARTING WORD ADDRESS.
	SUB	TAC1,TAC	;ADJUST REFERENCE - RELATIVE ADDRESS IN THE UPPER.
	TLNE	TAC1,377777	;UNDERFLOW?
	JRST	RELOC4		;YES, BETWEEN UPPER AND LOWER!
	HLRZ	TAC,AC1		;GET PROT.
	CAIGE	TAC,(TAC1)	;TOO BIG?
	JRST	RELOC4		;TOO BIG.  AVOID SKIP RETURN
	ADDI	TAC1,(AC1)
	MOVE	AC1,DAT		;RETURN IN AC1 THE ADDRESS OF THE PROT-REL WORD
	AOS	-2(P)		;NEED TO RESTORE DAT, TAC, AND SKIP.
	POP	P,DAT
	JRST	TPOPJ		;LOSE

;USE THIS ROUTINE AFTER CALLING RELOCA ONCE TO ASSURE
;THAT THE ADDRESS YOU ARE CHECKING IS IN THE SAME
;SEGMENT AS THE LAST ONE YOU CHECKED. DON'T CLOBBER
;AC1 BETWEEN CALLS ON RELOCA AND RELOCB
;CALLING:
;	MOVE J,<NUMBER OF JOB IN QUESTION>
;	MOVE TAC1,<ADDRESS YOU WISH CHECKED>
;	PUSHJ P,RELOCB
;	<ILLEGAL ADDRESS OR NOT IN SAME SEGMENT AS AC1>
;	<LEGAL ADDRESS AND IN RIGHT SEGMENT>

↑↑RELOCB:
	PUSH	P,AC1		;SAVE PROT RELOC WE USED LAST!
	PUSHJ	P,RELOCA	;DO THE RELOC THING
	JRST	RELOC5
	POP	P,(P)
	EXCH	AC1,1(P)
	CAMN	AC1,1(P)	;DID RELOCA USE PROT RELOC WE WANTED?
	AOS	(P)		;YES, SUCCESS
	POPJ	P,

RELOC5:	POP	P,AC1
	POPJ	P,		;LOSE


↑↑RELOCC:
	PUSHJ	P,RELOCA
	POPJ	P,
	TLNN	TAC1,17
	AOS	(P)
	POPJ	P,

↑↑RELOCD:
	PUSHJ	P,RELOCB
	POPJ	P,
	TLNN	TAC1,17
	AOS	(P)
	POPJ	P,
SUBTTL	LOCK AND UNLOCK UUOS.

PRINTX HIUSER BUGS

↑UNLOKC:MOVEI	J,(DAT)			;CALLED FROM CLOCK RQ AT ESTOP4
↑UNLOCK:PUSH	P,TAC
	MOVEI	TAC,JLOCK
	TDNN	TAC,JBTSTS(J)		;IS JOB LOCKED IN AT ALL?
	JRST	TPOPJ			;NO. THIS IS EASY.
	PUSH	P,PROG
	ANDCAM	TAC,JBTSTS(J)		;UNLOCK HIM.

IFN FTSTAT,<	MOVEI TAC,LOKSTA
		PUSHJ	P,STAPUT	>;FTSTAT

	MOVE	PROG,JBTPAG(J)		;GET THE ADDRESS OF THIS JOB.
	HLRZ	TAC,PROG
	ADDI	TAC,(PROG)		;COMPUTE ADDRESS ABOVE THIS JOB.
	CAME	TAC,LOKPAG		;SAME AS LOKTOP?
	JRST	UNLOK4			;NO. SIZE OF LOCKED CORE DOESN'T DIMINISH
UNLOK0:	PUSH	P,TAC1
	HRRZ	PROG,PROG		;PAGE NUMBER OF BOTTOM OF NEW UNLOCKED AREA.
UNLOK1:	MOVEI	TAC,-1(PROG)		;LOOK 1 PAGE FURTHER DOWN.
	PUSHJ	P,CORGB1		;GET A BYTE POINTER
	LDB	TAC1,TAC		;LOAD CORE CODE.
	JUMPE	TAC1,UNLOK2		;CORE IS FREE. (GIVE BACK TO CORTAL)
	MOVEI	TAC,JLOCK
	CAIGE	TAC1,101		;CORE IN SYSTEM?
	TDNE	TAC,JBTSTS(TAC1)	;NO. CORE BELONGS TO UNLOCKED USER?
	JRST	UNLOK3			;SYSTEM CORE OR LOCKED USER.
	JRST	.+2
UNLOK2:	AOS	CORTAL			;UNCLAIMED BLOCK: INCREMENT CORTAL
	SOJA	PROG,UNLOK1

UNLOK3:	HRRZM	PROG,LOKPAG
	LSH	PROG,=9
	MOVEM	PROG,LOKTOP
IFN FTCORBUG,<	PUSHJ	P,CORCHK  >	;MAKE SURE CORTAB AND CORTAL ARE CONSISTENT
	POP	P,TAC1			;RESTORE AC'S
UNLOK4:	POP	P,PROG
	JRST	TPOPJ

LOCK0:	JSP	TAC,UUOMES
	ASCIZ	/Can't LOCK with segment
/

↑LOCK:	LDB	TAC1,PSEGN
	JUMPN	TAC1,LOCK0
	SKIPE	LOCKNO
	CAMN	J,LOCKNO
	JRST	LOCK1
	MOVEI	TAC,JIFSEC/2		;CODE CAN'T BE REENTERED, SO
	PUSHJ	P,SLEEPT		;LET THIS GUY WAIT.
	JRST	LOCK

LOCK0A:	MOVEI	TAC,0			;DELAY UNTIL HIS IO STOPS
	PUSHJ	P,SLEEP
	JRST	LOCK

LOCK1:	PUSHJ	P,ANYACT		;WAIT UNTIL IO STOPS.
	JRST	LOCK0A
	MOVEI	AC2,JLOCK		;NOW WE DECIDE WHERE TO PUT THIS TURKEY.
	TDNE	AC2,JBTSTS(J)		;ARE WE LOCKED ALREADY?
	PUSHJ	P,UNLOCK		;YES. UNLOCK FIRST. (SHUFFLES IF POSSIBLE)
LOCK2A:	MOVE	LOC,FUPAG		;LOWEST POSSIBLE LOC OF HOLE.
	CAML	LOC,LOKPAG		;TOP OF LOCKED SPACE.
	JRST	LOCK2			;LOC CONTAINS PAGE WHERE TO LOCK.
LOCK1A:	TDZA	BLK,BLK			;SIZE OF THIS HOLE.
LOCK1B:	ADDI	BLK,1			;INCREMENT SIZE OF THIS HOLE.
LOCK1C:	CAML	LOC,LOKPAG		;PASSED THE LOCKED PART?
	JRST	LOCK1D			;YES. SEE IF IT WAS IN A HOLE.
	PUSHJ	P,CORGBP		;MAKE A BYTE POINTER
	LDB	TAC1,TAC		;PICKUP CORE USE BITS
	ADDI	LOC,1
	JUMPE	TAC1,LOCK1B		;JUMP IF STILL IN HOLE.
	CAIGE	TAC1,101		;SKIP IF THIS IS NOT A JOB
	TDNE	AC2,JBTSTS(TAC1)	;SKIP IF JOB IS UNLOCKED
	JRST	.+2			;IN SYSTEM OR IN LOCKED JOB.
	JRST	LOCK1B			;UNLOCKED JOB IS A LOGICAL HOLE.
	JUMPE	BLK,LOCK1C		;NOT IN HOLE. JUMP IF THERE WAS NO HOLE.
	HRLZ	TAC,JBTPAG(J)		;TAC←SIZE OF HOLE WE NEED.
	CAIG	BLK,(TAC)		;SKIP IF HOLE IS BIG ENOUGH.
	JRST	LOCK1A			;NOT BIG ENOUGH.
	SUBI	LOC,1(BLK)		;COMPUTE FIRST LOCATION OF HOLE.
	JRST	LOCK2			;LOC←FIRST PAGE OF DESIRED HOLE

LOCK1D:	SUBI	LOC,(BLK)		;DECREASE FOR HOLE AT TOP.
LOCK2:	HLL	LOC,JBTPAG(J)		;LOC←DESIRED NEW JBTPAG
	MOVEM	LOC,LOKPOS		;SAVE ADDRESS OF THE HOLE.
	CAMN	LOC,JBTPAG(J)		;SAME AS WHERE WE ARE NOW?
	JRST	LOCK4			;WE'RE IN LUCK. (LOCK)
	PUSHJ	P,LOCK5			;SEE IF WE CAN SHUFFLE TO THE RIGHT PLACE.
	JRST	LOCK3			;NO. LET THE CLOCK SWAP JOBS OUT.
					;HERE WE HAVE TO MOVE OURSELVES IN.

	MOVE	PROG,JBTPAG(J)
	HLRZ	TAC,JBTPAG(J)		;DESIRED CORE SIZE
	HRRZ	LOC,JBTPAG(J)		;FIRST PAGE OF OLD ASSIGNMENT
	HLRZ	BLK,JBTPAG(J)		;NUMBER OF PAGES IN OLD ASSIGNMENT

IFN FTPAGER,<	PUSHJ P,LMAPL		;RELEASE OLD PAGE TABLE ENTRIES
		 SETZM (TAC1)		>;FTPAGER

	MOVEI	UCHN,0
	PUSHJ	P,CORSTG		;FREE OLD CORE.
	HRRZ	LOC,LOKPOS		;THIS IS THE ADDRESS OF THE NEW ASSIGNMENT.
	PUSHJ	P,CORGT1		;MAKE IT SHUFFLE
	JFCL				;ALWAYS SKIPS.
LOCK4:
IFN FTSTAT,<	MOVEI	TAC,LOKSTA+100
		PUSHJ	P,STAPUT	>;FTSTAT

	MOVEI	TAC,JLOCK
	IORM	TAC,JBTSTS(J)		;TELL THEM WE'RE LOCKED IN.
	MOVE	PROG,JBTPAG(J)		;JOB IS NOW IN THE RIGHT PLACE.
	HLRZ	TAC,PROG		;GET PROT
	ADDI	TAC,(PROG)		;FIRST ADDRESS ABOVE THIS JOB
	CAMG	TAC,LOKPAG		;IS THIS GREATER THAN OLD LOKTOP?
	JRST	LOCK99			;NO.  THEN THERE'S NOTHING SPECIAL.
;CORTAL SHOULD BE OK. JOB WAS MOVED TO CORE WHICH WASN'T LOCKED CORE AT THAT TIME.
	MOVEM	TAC,LOKPAG		;STORE NEW FIRST UNLOCKED PAGE
	LSH	TAC,=9
	MOVEM	TAC,LOKTOP
LOCK99:	PUSHJ	P,SPWCNT		;CONTINUE HIS SPACEWAR JOB IF SUSPENDED
	SETZM	LOCKNO			;CLEAR THIS.
	MOVE	TAC,JBTPAG(J)
	LSH	TAC,=9
	SUB	TAC,[1,,0]
	JRST	STOTAC

LOCK5:	HRRZ	LOC,LOKPOS		;GET BASE LOCATION
	HLRZ	AC3,LOKPOS		;AND THE PROTECTION.
LOCK5A:	PUSHJ	P,CORGBP		;MAKE A BYTE POINTER IN TAC.
	LDB	TAC1,TAC		;GET CORE USE BITS
	CAIN	TAC1,(J)		;SAME AS OUR JOB
	JRST	CPOPJ1			;YES. THEN WE CAN MOVE IN.
	JUMPN	TAC1,CPOPJ		;SOME ONE IS THERE. WE HAVE TO WORK HARD.
	ADDI	LOC,1
	SOJG	AC3,LOCK5A
	JRST	CPOPJ1			;WE'RE ALL FREE.


LOCK3:	MOVEM	J,LOCKNO		;TELL THE SWAPPER TO FOREGO SWAPIN.
	PUSHJ	P,LOCKPL		;PLANT CLKRQ FOR LOCK.
	MOVNI	TAC,IOWQ		;REQUE THIS JOB TO IOWQ
	MOVEM	TAC,JOBQUE(J)
	PUSHJ	P,WSCHED		;WAIT FOR REACTIVATION
	CAME	J,LOCKNO		;AVOID ↑C CONTINUE HANGUP
	JRST	LOCK			;REENTER THE LOCK RESOURCE
	MOVE	LOC,LOKPOS
	JRST	LOCK2A			;SEE IF ALL GOOD THINGS HAVE HAPPENED.
	
LOCK3A:					;HERE AT CLOCK LEVEL.
	SKIPGE	FSCLKF			;FREE STORAGE DOING IT TOO?
	JRST	LOCKPL			;YES. WAIT FOR IT TOO.
	SKIPN	FINISH
	SKIPE	FORCE
	JRST	LOCKPL			;WAIT FOR SWAPPER TO BE IDLE.
	SKIPE	J,LOCKNO
	SKIPL	JBTSTS(J)
	JRST	LOCK3C			;FLUSH CLOCK RQ IF JOB NOT THERE.
	PUSHJ	P,LOCK5			;SEE IF THERE'S A HOLE YET.
	JRST	LOCK3B			;NOT YET.
	MOVNI	TAC,TQ
	MOVEM	TAC,JOBQUE(J)		;SET JOB TO RUN AGAIN
	JRST	REQUE			;REQUEUE AND DISMISS CLOCK LEVEL.

LOCK3B:	MOVEI	J,(TAC1)		;GET JOB NUMBER OF THE GUY WE'RE FORCING
	MOVE	TAC,JBTSTS(J)
	TLNE	TAC,SHF!SWP		;SKIP IF HE'S NOT IN MOTION ALREADY
	JRST	LOCKPL			;WE'LL HAVE TO WAIT FOR HIM TO STOP MOVING
	HLRZ	TAC,JBTPAG(J)
	SKIPN	XJOB(J)			;IS HE ALREADY EXPANDING?
	PUSHJ	P,XPAND			;NO. LET'S GIVE HIM A SHOVE
LOCKPL:	MOVE	TAC,[LOCK3A,,1]		;PLANT A CLOCK REQUEST.
	CONO	PI,PIOFF
	IDPB	TAC,CLOCK
	CONO	PI,PION
	POPJ	P,

LOCK3C:	SETZM	LOCKNO
	POPJ	P,
;LTHMOV, HTLMOV

IFN FTHPSG,<

↑LTHUUO:LDB	J,PSEGN
	JUMPE	J,CPOPJ
	JUMPL	TAC,UUOERR
	CAILE	TAC,1
	JRST	UUOERR
	JUMPG	TAC,HTLMOV
	PUSHJ	P,MAPSET		;SETUP MAP TO MAKE UPPER LOOK LIKE MAIN JOB

;LOW TO HIGH MOVE.  CALL WITH J=JOB TO MOVE.  ASSUMES MAP IS SETUP FOR J AS JOB.

↑LTHMOV:SKIPN	AC3,JBTMAP(J)		;SKIP IF A MAP EXISTS.
	POPJ	P,
	LSH	AC3,=9
	HRLI	AC3,-1000		;AOBJN POINTER TO USER'S MAP.
	MOVEI	AC2,0			;COUNT USER'S PAGES THAT GO TO HI CORE
LTHM1:	SKIPN	TAC1,(AC3)		;IS THERE A PAGE HERE?
	JRST	LTHM1B			;NO.
	HRRZ	TAC1,TAC1
	CAIGE	TAC1,1000		;SKIP IF PAGE ALREADY LIVES IN HI CORE
	ADDI	AC2,1			;COUNT A PAGE THAT WE MUST MOVE
LTHM1B:	AOBJN	AC3,LTHM1
	JUMPE	AC2,CPOPJ1		;WIN IF ALL HIS PAGES ARE HI, OR NO PAGES.
	CAMLE	AC2,CORHTL		;WILL THIS FIT IN HI CORE?
	POPJ	P,			;NO.  SORRY CHARLIE.
	MOVE	AC3,JBTMAP(J)
	LSH	AC3,=9
	HRLI	AC3,-1000
	MOVE	LOC,FHUPAG		;SEARCH FOR FREE PAGES IN HI CORE.
LTHM2:	SKIPN	TAC1,(AC3)		;IS THIS OLD PAGE IN LOW CORE?
	JRST	LTHM2Z			;NO SUCH PAGE.
	HRRZ	TAC1,TAC1
	CAIL	TAC1,1000
	JRST	LTHM2Z			;THIS PAGE IS IN HI CORE ALREADY
	CAIA
LTHM2A:	ADDI	LOC,1
	CAML	LOC,LHUPAG		;HAS LOC RUN AMOK?
	JRST	4,.			;YES.  LOSE.
	LDB	TAC1,COREP		;GET A CORTAB BYTE
	JUMPN	TAC1,LTHM2A		;JUMP IF CLAIMED.
	DPB	J,COREP			;CLAIM THIS BLOCK FOR US.
	SOS	CORHTL			;COUNT IT AS IN USE.
	MOVEI	TAC1,SHFEXP		;CREATE AN EXEC PAGE POINTING TO THE
	MOVEI	TAC,(LOC)		;DESTINATION PAGE
	PUSHJ	P,ADDEMP		;DESTINATION PAGE IS MAPPED ONTO SHFEXP
NOKL10,<	CONO	PAG,1			>;NOKL10
IFKL10,<	CONO	KLPAG,660000+KLEPT⊗-=9	>;IFKL10
	HLLZ	TAC,AC3
	ADD	TAC,[1000,,SHFEXP]	;TAC←USER PAGE NUMBER,,EXEC PAGE NUMBER
	LSH	TAC,=9			;TAC←USER ADDRESS,,EXEC ADDRESS
	XCTR	XBLTR,[BLT TAC,SHFEXP⊗9+777]
	SETZM	EXPGT+SHFEXP		;DELETE MAP ENTRY FOR DESTINATION
	HRRZ	TAC,(AC3)		;TAC←PAGE NUMBER OF OLD PAGE FOR USER
	PUSHJ	P,CORGB1
	MOVEI	TAC1,0
	DPB	TAC1,TAC		;FREE CORE.
	AOS	CORTAL			;AND COUNT THE LOW-CORE FREE COUNT
	HRRM	LOC,(AC3)		;STORE NEW MAP ENTRY FOR THIS USER.
	SOJLE	AC2,LTHM3		;COUNT A PAGE MOVED.  JUMP IF DONE
LTHM2Z:	AOBJN	AC3,LTHM2		;LOOP MOVING PAGES
LTHM3:	MOVE	AC3,JBTMAP(J)
	LSH	AC3,=9
	HRRZ	TAC,(AC3)		;GET PAGE NUMBER OF VIRTUAL PAGE 0
	HRRM	TAC,JBTPAG(J)		;STORE AS USER'S FIRST PAGE.
NOKL10,<	CONO	PAG,3			>;NOKL10
IFKL10,<	CONO	KLPAG,660000+KLEPT⊗-=9	>;IFKL10

	PUSHJ	P,HCBUG			;GOD BLESS US, EVERY ONE.

	MOVE	AC3,JBTSTS(J)
	TLNE	AC3,JSEG		;SKIP UNLESS THIS IS A SEGMENT
	PUSHJ	P,AUPMAP		;FOR SEGMENT, SPREAD NEW MAP TO ALL LOWERS
	JRST	DIDLE9			;RECOMPUTE SWAPPING PARAMS.  SKIP

;HIGH TO LOW MOVE.  CALL AT UUO LEVEL WITH J=JOB NUMBER TO MOVE.

↑HTLMOV:HRRZ	TAC,JBTPAG(J)
	CAIGE	TAC,1000		;IS THIS JOB IN HIGH CORE?
	POPJ	P,			;NO.  THAT WAS EASY
	JRST	HTLMV2

HTLMV1:	PUSHJ	P,WSCHED		;WAIT FOR IO TO STOP
HTLMV2:	PUSHJ	P,ANYACT
	JRST	HTLMV1			;IO STILL ACTIVE
	HLRZ	TAC,JBTPAG(J)
	DPB	TAC,IMGIN
	DPB	TAC,IMGOUT
	MOVSI	TAC,SWP
	IORM	TAC,JBTSTS(J)		;MARK THE JOB AS HAVING BEEN SWAPPED OUT
	JRST	WSCHED			;EXIT TO WSCHED VIA MAPSET

;ENTER HERE FROM SWAPPER WHEN THERE'S LOW CORE AVAILABLE.
;J=JOB NUMBER. TAC=DESIRED CORE SIZE (IN PAGES).

↑HTLFIN:PUSHJ	P,HOLSRC		;LOOK FOR A HOLE IN LOWCORE
	POPJ	P,			;LOSE.  NONE EXISTS.
;LOC=NEW LOCATION.  TAC=NEW SIZE.
	PUSHJ	P,APRMAP		;SETUP MAP (SWAPPER PUSHED MAP)
	MOVSI	PROG,(TAC)
	HRRI	PROG,(LOC)		;SETUP PROG FOR CALL TO DIDDLE
	MOVE	AC3,JBTMAP(J)
	LSH	AC3,=9
	HRLI	AC3,-1000
	PUSH	P,TAC			;COUNT OF PAGES TO MOVE
HTLFN1:	SKIPN	TAC,(AC3)		;IS THERE A HIGH PAGE HERE?
	JRST	HTLFN2			;NO PAGE AT ALL
	HRRZ	TAC,TAC
	CAIGE	TAC,1000
	JRST	HTLFN2			;THIS PAGE IS ALREADY LOW.
	PUSHJ	P,CORGB1
	LDB	TAC1,TAC
	CAIE	TAC1,(J)
	HALT	.+1
	MOVEI	TAC1,0
	DPB	TAC1,TAC		;FREE HIGH CORE BYTE
	AOS	CORHTL			;FREE HIGH CORE BYTE
	MOVEI	TAC,(LOC)
	PUSHJ	P,CORGB1
	LDB	TAC1,TAC
	JUMPE	TAC1,.+2
	HALT	.+1
	DPB	J,TAC			;CLAIM LOWCORE BYTE
	SOS	CORTAL
	MOVEI	TAC1,SHFEXP
	MOVEI	TAC,(LOC)
	PUSHJ	P,ADDEMP
NOKL10,<	CONO	PAG,1			>;NOKL10
IFKL10,<	CONO	KLPAG,660000+KLEPT⊗-=9	>;IFKL10
	HLLZ	TAC,AC3
	ADD	TAC,[1000,,SHFEXP]
	LSH	TAC,=9			;USER'S ADDRESS,,EXEC PAGE ADDRESS
	XCTR	XBLTR,[BLT TAC,SHFEXP⊗9+777]
	SETZM	EXPGT+SHFEXP
	HRRM	LOC,(AC3)		;UPDATE USER'S MAP
	ADDI	LOC,1
	SOSG	(P)
	JRST	HTLFN3			;LEAVE IF COUNT IS EXHAUSTED
HTLFN2:	AOBJN	AC3,HTLFN1
HTLFN3:	SUB	P,[1,,1]
NOKL10,<	CONO	PAG,1		
		CONO	PAG,3		>;NOKL10
IFKL10,<	CONO	KLPAG,660000+KLEPT⊗-=9	>;IFKL10

	PUSHJ	P,HCBUG

	MOVEI	LOC,(PROG)		;SETUP FOR DIDLE
	MOVEI	BLK,0
	JRST	DIDLE


HCBUG:	PUSH	P,J
	PUSH	P,LOC
	PUSH	P,AC2
	PUSH	P,TAC

	MOVEI	J,JOBN-1
HCB1:	SKIPN	AC2,JBTPAG(J)
	JRST	HCB2
	MOVEI	LOC,(AC2)
	CAIGE	LOC,1000
	JRST	HCB2
	MOVE	AC2,JBTMAP(J)
	LSH	AC2,=9
	HRLI	AC2,-1000
HCB1A:	SKIPN	LOC,(AC2)
	JRST	HCB1B
	LDB	TAC,COREP
	CAIN	TAC,(J)
	JRST	HCB1B
	PUSHACS
	PUSHJ	P,DISJOB
	PUSHJ	P,DISMES
	ASCIZ	/ JBTMAP - CORTAB INCONSISTENT.  FIX IT OR RELOAD.
/
	PUSHJ	P,DISFLU
	POPACS
	PUSHJ	P,DDTCALL

HCB1B:	AOBJN	AC2,HCB1A
HCB2:	SOJG	J,HCB1
	POP	P,TAC
	POP	P,AC2
	POP	P,LOC
	POP	P,J
	POPJ	P,

>;IFN FTHPSG
SUBTTL	FREE STORAGE	;AND OTHER POLITICAL PRISONERS
; "AND WHO DESERVES THE CREDIT?  AND WHO DESERVES THE BLAME?
; NIKCOLI IVANOVITCH LOBACHEVSKY IS HIS NAME."

;		JAM - ORIGINAL FREE STORAGE SYSTEM
;		REG - REVISED SYSTEM MARCH 1972

;	ACCUMULATOR DEFINITIONS

SIZE←AC3		;INPUT PARAMETER TO FSGET
BLOCK←AC1		;BLOCK ADDRESS OF FS BLOCK (BLK)

PICMSK←←37		;MASK TO SELECT CHANNELS 3,4,5,6,7 IN CONO/I PI
PICHON←←2000		;BIT TO TURN ON SELECTED CHANNELS: CONO PI
PICHOF←←1000		;BIT TO TURN OFF SELECTED CHANNELS

;THE FREE STORAGE SYSTEM ASSUMES THAT CHANNELS 1 AND 2 NEVER REQUEST
;FREE STORAGE.

;INITIALIZE FREE STORAGE - FSINIT


COMMENT $	

MEMSIZ:			<LOWEST WORD OF FREE STORAGE AREA>
RMEMSIZ:		<LOWEST NON-EX ADDRESS IN ALL CORE>

FREE STORAGE LOOKS LIKE:

BLOCK IN USE:			BLOCK THAT IS FREE

	(LOW ADDRESS)

---------------			---------------
| RS1  |  *---|→→→*		|  U   |  *---|→→→*
---------------   ↓		---------------   ↓
|             |   ↓		|             |   ↓
|             |   ↓		|             |   ↓
|             |   ↓		|             |   ↓
| DATA AREA   |   ↓		|             |   ↓
|             |	  ↓		---------------   ↓
|             |	  ↓		|   0  | BLINK|   ↓
---------------   ↓		---------------   ↓
|⊗ SIZE| RS2  |←←←*		| SIZE | FLINK|←←←*
---------------			---------------

	(HIGH ADDRESS)


WHERE SIZE IS THE TOTAL SIZE OF THE BLOCK IN WORDS.
THE DATA AREA HAS SIZE-2 WORDS. ⊗SIZE IS SIZE + 400000.
RS1 = reserved for free storage system future use.  Presently -1
RS2 = reserved for free storage system future use.  Presently 0
U IS UNDEFINED.
FLINK IS A FORWARD LINK IN A CHAIN OF FREE BLOCKS.
LINKS WILL EVENTUALLY POINT BACK TO THE BASE OF THE CHAIN!
BLINK IS A BACKWARD LINK IN A CHAIN OF FREE BLOCKS.

THERE ARE "NFSB" CHAINS OF FREE BLOCK WITH FORWARD AND
BACKWARD POINTERS IN FSAVB TABLE.


ALL FREE STORAGE BLOCKS ARE SOME MULTIPLE OF THE "TRIVIAL" SIZE.
ALL REQUESTS ARE ROUNDED UP TO SUCH A MULTIPLE.
CHAINS OF FREE BLOCKS OF EACH SIZE ARE KEPT WITH BASE POINTERS IN FSAVB.
$

↑FSINIT:
	SETZM	LOCKNO			;NO JOB IS ATTEMPTING TO LOCK
	MOVE	TAC,SYSTOP
	MOVEM	TAC,LOKTOP		;TOP OF LOCKED CORE IS SAME AS SYSTEM TOP.
	LSH	TAC,-=9
	MOVEM	TAC,LOKPAG		;FIRST UNLOCKED PAGE

	SETZM	FSBEG
	MOVE	TAC,[XWD FSBEG,FSBEG+1]
	BLT	TAC,FSEND
	SYNINI	FSCSC			;INITIALIZE INTERLOCK CELL

IFE FTEXPG,<				;(IN FTEXPG, WE ALWAYS START FRESH)
.FATAL this code hasn't been fixed!
	MOVE	LOC,MEMSIZ		;GET THE SIZE OF USER SPACE
	CAMN	LOC,RMEMSIZ		;SKIP IF WE HAVE SOME STORAGE CLAIMED
	JRST	FSINI2			;NO. WE HAVE NOTHING TO GIVE BACK
	PUSHJ	P,CORGBP		;GET A POINTER TO OUR LOWEST BLOCK
	MOVEM	TAC,CORLST		;SAVE AS POINTER TO THE END OF ALL CORE
	MOVEI	AC2,2000
FSINI1:	IDPB	AC2,CORLST		;CLEAR BLOCKS IN CORTAB
	ADDI	LOC,1000		;ADD TO BOTTOM OF FS.
	AOS	CORTAL			;INCREMENT CORE COUNT
	ADDM	AC2,CORMAX 		;INCREASE USER CORE
	CAME	LOC,RMEMSIZ		;AT THE TOP YET?
	JRST	FSINI1			;NO LOOP
	IBP	CORLST			;POINTS TO FIRST CORTAB BYTE THAT IS NXM
>;IFE FTEXPG

IFN FTEXPG,<	MOVE LOC,RMEMSIZ	>

FSINI2:	MOVEM	LOC,MEMSIZ		;SAVE RMEMSIZ AS MEMSIZ
	MOVNI	UCHN,FSNINIT*2		;NUMBER OF PAGES TO CLAIM NOW
	ADDM	UCHN,CORTAL		;DECREASE USER'S SPACE
	MOVNI	LOC,2000*FSNINIT	;GET - NUMBER OF WORDS CLAIMED
	ADDM	LOC,CORMAX		;DECREASE USER SPACE
	ADDB	LOC,MEMSIZ		;SET LOWER BOUND OF FS
	LSH	LOC,-=9
	MOVEM	LOC,MEMPAG		;PAGE NUMBER CORRESPONDING TO MEMSIZ
	MOVEI	UCHN,FSNINIT*2
FSINI3:	PUSHJ	P,CORGBP	
	MOVEI	TAC1,105
	DPB	TAC1,TAC		;CLAIM BLOCK FROM CORTAB

IFN FTEXPG,<	MOVEI	TAC1,(LOC)	;ADD THIS PHYSICAL PAGE 
		PUSHJ	P,ADDEVP	;TO THE EXEC MAP >;IFN FTEXPG

	ADDI	LOC,1
	SOJG	UCHN,FSINI3
	MOVE	UCHN,[XWD 2000*FSNINIT,FSAVB+2*NFSB-1]	;SIZE,,FLINK
	MOVE	AC2,RMEMSIZ		;FIRST NONEX ADDRESS
	SUBI	AC2,1			;ADDRESS OF HI END OF FIRST BLOCK
	MOVEM	UCHN,(AC2)		;SET SIZE,,FLINK IN TOP OF BLOCK
	HRRZM	UCHN,-1(AC2)		;SET BLINK
	MOVEM	AC2,@MEMSIZ		;ADDRESS OF TOP GOES INTO BOTTOM
	SETZ	UCHN,
FSINI5:	MOVEI	AC3,FSAVB+1(UCHN)	;GET ADDRESS OF SOMEONE
	MOVEM	AC3,FSAVB(UCHN)		;SAVE BACK POINTER
	MOVEM	AC3,FSAVB+1(UCHN)	;SAVE FORWARD POINTER
	ADDI	UCHN,2			;INCREMENT BY 2
	CAIGE	UCHN,2*NFSB-2		;ARE WE AT THE END YET?
	JRST	FSINI5			;NO KEEP LOOPING
	HRRZM	AC2,FSAVB+2*NFSB-2	;SAVE BACK POINTER TO ONLY BLOCK
	HRRZM	AC2,FSAVB+2*NFSB-1	;SAVE FORWARD POINTER TO ONLY BLOCK
	MOVEI	AC2,JIFSEC*=60		;NUMBER OF TICKS BETWEEN CHECKER CHECK
	MOVEM	AC2,FSCKCT		;SAVE
	MOVEI	UCHN,FSLIST		;GET THE START OF OUR Q SPACE
	MOVEM	UCHN,FSIPTR		;SAVE AS Q INPUT POINTER
	MOVEM	UCHN,FSOPTR		;AND Q OUTPUT POINTER
	JRST	SFSINI		;INITIALIZE FREE STORAGE SPARE LIST USERS


LOSYS

FSACSV:	EXCH	DAT,(P)		;PUSHJ P,FSACSV TO SAVE AC'S.
	PUSH	P,TAC
	PUSH	P,TAC1
	PUSH	P,AC2
	PUSH	P,SIZE
	PUSH	P,TEM
	JRST	(DAT)


FSACRS:	POP	P,TEM		;JSP DAT,FSACRS TO RESTORE AC'S
	POP	P,SIZE
	POP	P,AC2
	POP	P,TAC1
	POP	P,TAC
	EXCH	DAT,(P)
	POPJ	P,
COMMENT $	FSGET:	GET FREE STORAGE AT ANY LEVEL.


CALLING:
	MOVEI	SIZE,<BLOCK SIZE>	;SIZE≡AC3
	PUSHJ	P,FSGET
	<NONE AVAILABLE>
	<OK - ADDRESS OF BLOCK IS IN BLOCK (AC1)>

	UUO LEVEL ALWAYS GETS SUCCESS EXIT

ALTERNATE CALLS:
	FSGETU		;ENTER HERE AT UUO LEVEL.
			;GIVE ERROR RETURN INSTEAD OF WAITING

	FSGETP		;ENTER HERE GETS 1K BLOCK ALIGNED ON A 1K ADDRESS.
			;INITIAL CONTENTS OF SIZE ARE IGNORED.

$


FSSBYP:	POINT	17,(BLOCK),17		;POINTER TO SIZE FIELD OF BLOCK
FSSBP1:	POINT	17,(AC2),17		;POINTER TO SIZE WHEN BLOCK TOP IN AC2

FSGETP:	MOVEI	BLOCK,1			;HERE TO GET 1K ON A 1K BOUNDARY.
	JRST	FSGETV			;SIZE SETUP AS 1776

↑FSGET:	TDZA	BLOCK,BLOCK		;NORMAL CALL.
↑FSGETU:MOVNI	BLOCK,1			;CALL AT UUO LEVEL AND NEVER WAIT.
FSGETV:	CONSZ	PI,60000		;ARE WE TBELOW CHANNEL 2?
	JRST	FSGLUZ			;NO. SOMEONE SHOULD KNOW BETTER.
	CONSO	PI,77400		;ANY PI'S IN PROGRESS?
	SKIPE	INTACT(PID)		;WE'RE AT UUO LEVEL? USER INTERRUPT?
	JRST	.+2			;EITHER PI IN PROGRESS OR USER I-LEVEL
	MOVEM	BLOCK,FSGTUF		;NORMAL UUO LEVEL. SET SPECIAL FLAG.
					;  NEGATIVE MEANS DON'T WAIT TO GET FS.
	AOS	NFSGETS			;COUNT FS GETS
	PUSHJ	P,FSACSV		;SAVE  DAT,TEM,SIZE,AC2,TAC,TAC1
	PSYNC	FSCSC			;SYNCHRONIZE WITH OTHER PROCESSOR
	MOVEI	SIZE,2(SIZE)		;GET SIZE OF REQUEST +2
	TRZE	SIZE,TRIVIAL-1		;IS THIS EXACT MULTIPLE OF TRIVIAL?
	ADDI	SIZE,TRIVIAL		;NO. ADD TRIVIAL
FSGETT:	JUMPG	BLOCK,FSGPAG		;JUMP IF SPECIAL CALL TO GET 1K
	MOVEI	TAC,(SIZE)		;GET SIZE INTO TAC
	LSH	TAC,1-TSHF		;SHIFT TO MAKE INDEX
	SUBI	TAC,2			;NORMALIZE TO ZERO INDEX
	CAILE	TAC,2*NFSB-2		;ARE WE AT THE END OF THE TABLE?
	JRST	FSGTBX			;YES. LOOK FOR A BIG BLOCK
	LSH	TAC,-1
	AOS	FSRPQ(TAC)
	LSH	TAC,1
FSGT0:	MOVE	TAC1,TAC		;INDEX TO FIRST BASE INSPECTED
	MOVE	BLOCK,MEMSIZ		;FIND BLOCK WITH A HIGHER ADDRESS
FSGT1:	CAMGE	BLOCK,FSAVB+1(TAC1)	;ADDRESS BIGGER THAN OUR BEST?
	MOVE	BLOCK,FSAVB+1(TAC1)	;YES. REMEBER BEST ADDRESS
	ADDI	TAC1,2			;GO ON TO NEXT LIST BASE
	AOS	NFSLP1			;COUNT A LOOP OF TYPE1
	CAIGE	TAC1,2*NFSB		;STILL IN TABLE?
	JRST	FSGT1			;YES. LOOP
	CAMG	BLOCK,MEMSIZ		;FOUND ANY?
	JRST	FSGTW			;NO WE'LL HAVE TO WAIT...
	PUSHJ	P,FSGCL			;CALL ROUTINE TO CLAIM AND DELINK
	JRST	FSGT0			;THE CLAIM FAILED. LOOK AGAIN.
	JRST	FSGTC			;CLAIM OK

;CLAIM AND DELINK THE FS BLOCK POINTED TO BY (BLOCK).
;SKIP ON SUCCESS (LEAVES TAC1 AND TAC SETUP AS PARAMETERS FOR FSGTC5)
FSGCL:	CONI	PI,AC2			;GET PI CHANNEL STATUS
	ANDI	AC2,PICMSK		;ONLY CHANNELS 3,4,5,6,7
	CONO	PI,PICHOF(AC2)		;TURN OFF CHANNELS 3-7
	SKIPG	TAC1,(BLOCK)		;FLINK INTO TAC1
	JRST	FSGCLX			;BLOCK IS ALREADY CLAIMED!
	HRRZ	TAC,-1(BLOCK)		;BLINK INTO TAC
	HRRM	TAC1,(TAC)		;GO BACK AND RESET FLINK
	HRRM	TAC,-1(TAC1)		;GO FORWARD AND RESET BLINK
	CONO	PI,PICHON(AC2)		;RESTORE CHANNELS THAT WERE ON
	MOVSI	AC2,400000
	IORM	AC2,(BLOCK)		;TURN ON THE SIGN BIT TO CLAIM BLOCK
	JRST	CPOPJ1			;GIVE THE SKIP RETURN

FSGCLX:	CONO	PI,PICHON(AC2)		;RESTORE PI.
	POPJ	P,


;HERE TO GET A BIG FS BLOCK
FSGTBX:	AOS	FSRPQ+NFSB-1
FSGTB0:	HRRZ	BLOCK,FSAVB+2*NFSB-1	;GET THE FIRST LINK
FSGTB1:	AOS	NFSLP2			;COUNT A LOOP OF TYPE 2
	CAIG	BLOCK,FSAVB+2*NFSB-1	;FLINK > ADDRESS OF LIST BASE?
	JRST	FSGTW			;NO. WE'LL HAVE TO WAIT.
	SKIPG	AC2,(BLOCK)		;SKIP IF THIS BLOCK IS NOT CLAIMED
	JRST	FSGTB0			;HIGHER CHANNEL MUST HAVE GOT THIS ONE!
	HLRZ	TAC1,AC2		;GET THE SIZE FIELD
	CAIL	TAC1,(SIZE)		;SIZE BIG ENOUGH?
	JRST	FSGTB2			;YES. TRY TO CLAIM IT
	MOVEI	BLOCK,(AC2)		;LOAD NEXT FLINK
	JRST	FSGTB1			;LOOP

FSGTB2:	PUSHJ	P,FSGCL			;CLAIM THE BLOCK AND DELINK IT
	JRST	FSGTB0			;CLAIM FAILED.
	JRST	FSGTC			;GOT IT

FSGPAG:	HRRZ	BLOCK,FSAVB+2*NFSB-1	;GET THE FIRST LINK
	MOVEI	SIZE,1000		;1 PAGE NEEDED
FSGPG1:	AOS	NFSLP2			;COUNT A LOOP OF TYPE 2
	CAIG	BLOCK,FSAVB+2*NFSB-1	;FLINK > ADDRESS OF LIST BASE?
	JRST	FSGTWX			;NO.  WE'LL HAVE TO WAIT.
	SKIPG	AC2,(BLOCK)		;SKIP IF THIS BLOCK IS NOT CLAIMED
	JRST	FSGPAG			;HIGHER CHANNEL MUST HAVE GOT THIS ONE!
	HLRZ	TAC1,AC2		;GET THE SIZE FIELD
	CAIL	TAC1,(SIZE)		;SIZE BIG ENOUGH?
	JRST	FSGPG3			;YES. SEE IF IT IS REALLY BIG ENOUGH.
FSGPG2:	MOVEI	BLOCK,(AC2)		;LOAD NEXT FLINK
	JRST	FSGPG1			;LOOP

FSGPG3:	MOVN	TAC1,TAC1		;-SIZE OF BLOCK
	ADDI	TAC1,1
	ADDI	TAC1,(BLOCK)		;ADDRESS OF BLOCK BOTTOM.
	TRNE	TAC1,777		;IS LOW ADDRESS ALREADY ON A PAGE BOUNDARY?
	ADDI	TAC1,1000		;NO.  INCREASE TO LOWEST PAGE BOUND IN BLOCK
	TRZ	TAC1,777		;TAC1←LOWEST PAGE BOUNDARY ADDRESS IN BLOCK
	MOVEI	TAC,(BLOCK)
  	ADDI	TAC,1			;ADDRESS OF NEXT HIGHER BLOCK
	TRZ	TAC,777			;TAC←HIGHEST PAGE BOUNDARY ADDRESS IN BLOCK
	SUBI	TAC,1000		;SEE IF THERE'S ANY SPACE THERE TO TAKE PAGE
	CAMGE	TAC,TAC1		;IF HIGH-PAGE IS AT LEAST AS BIG AS LOW
	JRST	FSGPG2			;LOSE.  ADVANCE TO NEXT FS BLOCK
	PUSHJ	P,FSGCL			;CLAIM THE BLOCK AND DELINK IT
	JRST	FSGPAG			;CLAIM FAILED.
;DON'T CLOBBER TAC AND TAC1 - NEEDED BY FSGTC5
	MOVEI	AC2,(BLOCK)
	ADDI	AC2,1			;ADDRESS OF NEXT HIGHER BLOCK
	TRZ	AC2,777			;AC2←HIGHEST PAGE BOUNDARY ADDRESS IN BLOCK
	SUBI	AC2,1			;THIS IS DESIRED BLOCK TOP.
	CAIL	AC2,(BLOCK)		;DIFFERENT FROM BLOCK?
	JRST	FSGTC			;NO.  RETURN 1K PIECE OF BLOCK
;RANGE (AC2)+1 TO (BLOCK) IS DISCARDED.  AC2 (ENDS IN 777) IS IMPORTANT PART.
	PUSH	P,AC2			;ADDRESS OF IMPORTANT PART (ENDS IN 1777)
	HRROM	BLOCK,1(AC2)		;MAKE DISCARD BLOCK.   LOWER BLK POINTER
	LDB	DAT,FSSBYP		;SIZE OF BIG BLOCK
	MOVEI	TEM,(BLOCK)		;HIGHEST ADDRESS IN BIG BLOCK.
	SUBI	TEM,(AC2)		;TEM←SIZE OF DISCARD BLOCK
	SUBI	DAT,(TEM)		;DAT←SIZE OF IMPORTANT PIECE
	IORI	DAT,400000
	HRLZM	DAT,(AC2)		;STUFF SIZE OF IMPORTANT PIECE IN TOP.
	TRZ	DAT,400000		;CLEAR CLAIM BIT.
	SUBM	AC2,DAT			;LOW ADDR OF IMPORTANT PIECE
	HRRZM	AC2,1(DAT)		;NEW LOWER BLK POINTER. (LOOKS FREE)
	IORI	TEM,400000		;SIZE OF DISCARD - SET CLAIM
	HRLZM	TEM,(BLOCK)		;DISCARD BLOCK NOW LOOKS CLAIMED.
	MOVEI	BLOCK,2(AC2)		;GIVE BACK DISCARD BLOCK.
	PUSHJ	P,FSQUIK		;RETURN DISCARD AS WE LEAVE VIA FSGRT1
	POP	P,BLOCK			;ADDRESS OF IMPORTANT PART.
					;FALL INTO FSGTC
;FSGTC - TRIM THE BLOCK WE CLAIMED TO THE SIZE WE REQUESTED.  IF THE
;REMAINDER EXCEEDS 170 WORDS THEN WE USE TAC AND TAC1 (AS SETUP BY
;FSGCL) TO HELP RETURN THE REMAINDER NOW.  IF THE REMAINDER IS SMALL,
;IT IS PLACED ON THE RETURN LIST, WHERE IT WILL BE RETURNED NEXT CLOCK
;TICK, OR, IF WE'RE AT CH7 OR UUO LEVEL IT'S RETURNED AS WE EXIT VIA FSGRT1
FSGTC:	LDB	AC2,FSSBYP		;GET THE SIZE OF THIS BLOCK
	SETZ	TEM,			;INITIALIZE EXCESS SIZE
	CAIGE	AC2,TRIVIAL(SIZE)	;IS BLOCK TOO BIG?
	JRST	FSGTC1			;NO
	MOVE	TEM,AC2			;GET THE SIZE
	SUBI	TEM,(SIZE)		;GET EXCESS SIZE
	MOVEI	AC2,(SIZE)		;GET THE SIZE TO USE
	DPB	AC2,FSSBYP		;SET SIZE
FSGTC1:	HLLZS	(BLOCK)			;CLEAR RIGHT SIDE OF TOP MARK
	SUBM	BLOCK,AC2		;AC2 GETS ADDRESS BELOW LOWEST
	HRROM	BLOCK,1(AC2)		;SET UP POINTER IN THE LOW ADDRESS
	JUMPE	TEM,FSGTCR		;ALL DONE IF NO SPLIT
	HRLZM	TEM,(AC2)		;SET SIZE IN SPLIT BLOCK
	SUBM	AC2,TEM			;GET LOWEST ADDRESS OF THIS, -1
	HRRZM	AC2,1(TEM)		;SET UP FORWARD LINK
	HLRZ	TEM,(AC2)		;GET THE SIZE BACK
	CAIGE	TEM,NFSB*TRIVIAL	;IS BLOCK VERY BIG?
	JRST	FSGTC4			;NO. RETURN THE SPLIT BY THE CLOCK
	JRST	FSGTC5			;TAC AND TAC1 WERE SETUP BY FSGCL

;HERE WE TRY TO RELINK THE REMAINDER INTO THE FREE LIST,
;IF THIS FAILS, WE RETURN THE REMAINDER VIA THE RETURN-LIST MECHANISM
FSGTC2:	CONO	PI,PICHON(TEM)		;TURN CHANNELS ON AGAIN
FSGTC5:	SKIPG	(TAC1)			;LOOK AHEAD
	JRST	FSGTC6			;LOSE
	MOVE	DAT,-1(TAC1)		;GET BLINK AHEAD
	HRRM	DAT,-1(AC2)		;SET BLINK HERE
	HRRM	TAC1,(AC2)		;SET FLINK HERE
	CONI	PI,TEM			;GET PI STATUS
	ANDI	TEM,PICMSK
	CONO	PI,PICHOF(TEM)		;TURN OFF CHANNELS
	SKIPLE	(TAC1)			;GRABBED FROM UNDER US?
	CAME	DAT,-1(TAC1)		;BE SURE
	JRST	FSGTC2			;TRY AGAIN
	HRRM	AC2,-1(TAC1)		;SET BLINK AHEAD
	HRRM	AC2,(DAT)		;SET FLINK BEHIND
	CONO	PI,PICHON(TEM)		;TURN ON PI'S AGAIN
	JRST	FSGTCR			;RETURN FREE STORAGE.

FSGTC3:	CONO	PI,PICHON(TEM)
FSGTC6:	SKIPG	DAT,(TAC)
	JRST	FSGTC4			;LINK'S HAVE MOVED
	HRRM	DAT,(AC2)		;SET FLINK HERE
	HRRM	TAC,-1(AC2)		;SET BLINK HERE
	CONI	PI,TEM
	ANDI	TEM,PICMSK
	CONO	PI,PICHOF(TEM)
	CAME	DAT,(TAC)		;THESE GUYS STILL THE SAME?
	JRST	FSGTC3			;LINKS HAVE MOVED. TRY AGAIN
	HRRM	AC2,-1(DAT)		;SET BLINK AHEAD
	HRRM	AC2,(TAC)		;SET FLINK BEHIND
	CONO	PI,PICHON(TEM)
	JRST	FSGTCR			;RETURN BLOCK

FSGTC4:	MOVSI	TAC,400000
	IORM	TAC,(AC2)
	LDB	TAC,FSSBP1
	SUBM	AC2,TAC
	HRROM	AC2,1(TAC)
	PUSH	P,BLOCK
	MOVEI	BLOCK,2(TAC)
	PUSHJ	P,FSQUIK		;ADD BLOCK TO FSRTL.
	POP	P,BLOCK
FSGTCR:	LDB	TAC,FSSBYP		;GET THE SIZE
	ADDM	TAC,FSBUSY		;ADD TO CLAIMED AMOUNT.
	SUBI	BLOCK,-2(TAC)		;COMPUTE LOWEST USABLE ADDRESS
	CONSO	PI,77000		;SKIP IF AT HI PI CHANNEL
	SKIPN	FSRTL			;LOW CHANNEL. SKIP IF ANY COMING BACK
	JRST	FSGRT1			;NOTHING TO DO OR MUST RETURN QUICK
	PUSH	P,BLOCK
	PUSHJ	P,FSCKX			;GIVE IT BACK TO THE INDIANS
	POP	P,BLOCK
FSGRT1:	XSYNC	FSCSC
	JSP	DAT,FSACRS
	PUSH	P,[FSGET]		;IN CASE OF TROUBLE TRY AGAIN
	PUSHJ	P,FSECHK		;INCASE OF ERROR, RETURN UPLEVEL.
	POP	P,(P)			;FLUSH STACK
	JRST	CPOPJ1			;AND GIVE SKIP RETURN

;HERE IF WE COULDN'T FIND ANY FREE STORAGE.
FSGTW:	TDZA	BLOCK,BLOCK		;NORMAL ENTRY
FSGTWX:	MOVEI	BLOCK,1			;ENTRY FOR NEED 1K ON A 1K BOUNDARY
	PUSHJ	P,FSGETK		;WE NEED ANOTHER K, GET IT
	JRST	FSGTW5			;CAN'T GET ANOTHER K
	PUSHJ	P,FSWAKE		;WAKE SOMEONE WHO WAITS
	JRST	FSGETT			;FSGET RETRY THIS ONE

FSGTW5:	CONSO	PI,77400		;ARE WE AT I-LEVEL?
	SKIPGE	FSGTUF			;NOT I-LEVEL, WANT TO RETURN QUICK?
	JRST	FSGFAI			;GIVE THE NON-SKIP RETURN
	SKIPE	INTACT(PID)		;IF YOU'RE AT USER I-LEVEL YOU'LL
	JRST	WSCHED			;BE KICKED OUT BY WSCHED....
	AOS	NFSWAITS		;COUNT A WAIT
	PUSH	P,J			;SAVE J ON THE STACK
	MOVE	J,JOB(PID)		;GET THE JOB NUMBER
	HRL	J,SIZE			;GET THE SIZE OF REQUEST
	MOVEM	J,@FSIPTR		;SAVE IN OUR QUEUE OF JOBS
	AOS	TAC,FSIPTR		;INCREMENT THE POINTER
	CAIL	TAC,FSLIST+JOBN
	MOVEI	TAC,FSLIST
	MOVEM	TAC,FSIPTR
	AOS	FSCNT
	XSYNC	FSCSC
	PUSHJ	P,WSCHED		;CALL CH7 TO RESCHEDULE JOB(PID)
	SETZM	FSGTUF			;ZERO THIS CELL SO IF WE FAIL AGAIN, WE WAIT
	PSYNC	FSCSC			;HERE EVENTUALLY AFTER FSWAKE
	PUSHJ	P,FSWAKE		;WAKE SOMEONE ELSE
	POP	P,J			;RESTORE J, FINALLY.
	JRST	FSGETT			;PLAY IT AGAIN, SAM.

FSGFAI:	XSYNC	FSCSC
	JSP	DAT,FSACRS		;RESTORE AC'S
	AOS	NFSGFA			;COUNT A FAILURE
	POPJ	P,			;CRY

FSGLUZ:	HRRZ	BLOCK,(P)		;GET RETURN ADDRESS
	PUSHACS
	PUSHJ	P,DISERR
	[ASCIZ/ FSGET CALLED ILLEGALLY FROM PI CHANNEL 1 OR 2
RETURN ADDRESS = /]
	DISARG ( LOC,<BLOCK-20(P)> )
	[ASCIZ/
/]
	-1
	POPACS
	JUMPE	PID,CPOPJ
	HALT	CPOPJ			;STOP THE PDP-6
;SWIPE 1K FROM AVAILABLE USER SPACE.
;THIS CAN BE DONE ONLY AT CLOCK OR UUO LEVEL.
;IT SETS THE FOLLOWING GLOBAL VALUES:
; CORLST		BYTE POINTER SET TO THE SECOND UNAVAILABLE 1K BLOCK.
; CORTAL		NUMBER OF 1K BLOCKS AVAILABLE TO USERS
; CORMAX		MAXIMUM NUMBER OF WORDS A JOB MAY HAVE.
; MEMSIZ		LOWEST LOCATION USED BY FREE STORAGE

FSGETK:	CONSO	PI,77000		;SKIP IF PI IN PROGRESS (EXCEPT CLKCHN)
	JUMPE	PID,FSGTKZ		;CH7 OR UUO LEVEL. JUMP IF P1 (TO HISYS)
	POPJ	P,			;CAN'T DO THIS ABOVE CH7 OR ON P2

HISYS

FSGTKZ:	MOVE	TAC,MEMPAG		;GET THE CURRENT MEMORY SIZE
	SUBI	TAC,1			;GET LOWEST ADDRESS WE WANT
	PUSHJ	P,CORGB1		;MAKE A BYTE POINTER TO CORTAB
	LDB	TAC1,TAC		;PICK UP MARK BIT FOR THIS BLOCK
	JUMPN	TAC1,FSSWAP		;JUMP IF CLAIMED AND FORCE USER OUT
	MOVEI	TAC1,105		;CLAIM THIS BLOCK!
	DPB	TAC1,TAC		;STUFF OUR CLAIM BIT IN
	MOVNI	TAC,1000		;UPDATE 4 GLOBAL CELLS
	ADDM	TAC,CORMAX 		;MAXIMUM CORE SIZE IN WORDS
	ADDM	TAC,MEMSIZ		;BOTTOM OF FREE STORAGE
	SOS	TAC1,MEMPAG
	SOS	CORTAL			;NUMBER OF PAGES FOR USERS

IFN FTEXPG,<	PUSHJ	P,ADDEVP	;ADD PHYSICAL PAGE = VIRTUAL PAGE >;FTEXPG

IFKL10,<	PUSHJ	P,SWEEPA	;MAKE SURE CACHE DOESN'T GET ANY>

IFN FTCORBUG,<	PUSHJ	P,CORCHK >	;CHECK VALIDITY OF CORE TABLES.

	PUSH	P,LOC
	PUSH	P,UCHN
	PUSH	P,BLOCK
	PUSH	P,SIZE
	PUSHJ	P,DIDLE4		;SET UP SWAPPER PARAMTERS
	MOVE	BLOCK,MEMSIZ		;GET THE LOW BOUND OF FS.
	ADDI	BLOCK,777		;POINTER TO HIGH SIDE OF THIS PAGE
	MOVSI	TAC,401000		;SET UP SIZE AND USE BIT
	MOVEM	TAC,(BLOCK)		;STUFF IN BLOCK HEADER
	HRROM	BLOCK,@MEMSIZ		;STUFF IN LOWER MARKER
	MOVE	BLOCK,MEMSIZ
	ADDI	BLOCK,1
	PUSHJ	P,FSGIVX		;GIVE BACK A 1K BLOCK (MERGES)
	POP	P,SIZE
	POP	P,BLOCK
	POP	P,UCHN
	POP	P,LOC
	SETZM	FSGVKF			;FLUSH WARNING ABOUT BOTTOM K.
	JRST	CPOPJ1			;GIVE A SKIP RETURN FROM FSGETK

;ROUTINE TO FORCE THE JOB AT TOP OF CORE OUT.

FSSWAP:	MOVE	TAC,MEMPAG		;FIND OUT WHO'S AT THE TOP OF CORE
	SUBI	TAC,1			;THIS IS THE ADDRESS OF SOME BLOCK
	PUSHJ	P,CORGB1
	PUSH	P,J			;DON'T CLOBBER J
	LDB	J,TAC			;GET JOB NUMBER OF THE GUY TO FORCE
	MOVE	TAC,JBTSTS(J)
	TLNE	TAC,SWP!SHF		;IS HE IN MOTION?
	JRST	FSWP3A			;CAN'T DO HIM NOW.
	HLRZ	TAC,JBTPAG(J) 
	SKIPN	XJOB(J)
	PUSHJ	P,XPAND			;MAKE HIM GET SHOVED OUT
FSWP3A:	POP	P,J			;RESTORE J
FSSWP3:	SETOM	FSCLKF			;TELL FSCLK TO THINK ABOUT GOBBLING
	SETOM	FSNCLK			;TELL CLKSER TO RUN FSCLK
	POPJ	P,			;AND RETURN


; THIS ROUTINE REQUEUES A JOB WHEN CORE IS AVAILABLE FOR HIM.

FSWAKE:	CONO	PI,PIOFF
	SKIPLE	FSCNT			;ANYONE THERE?
	JRST	FSWAK1			;YES
	SETZM	FSCNT
	CONO	PI,PION
	POPJ	P,			;NO WORK FOR NO ONE

FSWAK1:	SOS	FSCNT			;DECREASE NUMBER OF WAITERS
	CONO	PI,PION
	HRRZ	J,@FSOPTR		;GET JOB NUMBER TO REQUEUE
	AOS	TAC,FSOPTR
	CAIL	TAC,FSLIST+JOBN
	MOVEI	TAC,FSLIST
	MOVEM	TAC,FSOPTR
	SKIPL	JBTSTS(J)		;IS THIS GUY STILL RUNABLE?
	JRST	FSWAKE			;NO. TRY ANOTHER ONE.
	MOVNI	TAC,RUNQ
	MOVEM	TAC,JOBQUE(J)		;SET QUEUE FOR THIS JOB
	JRST	REQUE			;REQUEUE THIS JOB

;FSCLK:	CLOCK LEVEL (CHANNEL 7) ROUTINES TO KEEP FREE STORAGE HAPPY!
;CALLED FROM CLKSER, NEAR CALL ON DPYCLK

↑FSCLK:	SETZM	FSNCLK			;WE HAVE GOTTEN SERVICE. SHUT OFF FLAG.
	PSYNC	FSCSC			;SYNCRONIZE
	PUSHJ	P,FSCKX			;RETURN CONTENTS OF FSRTL.
FSCKY:	SKIPN	FSCLKF			;ARE WE WAITING FOR THE SWAPPER?
	JRST	FSCLK1			;NO. SKIP THIS MESS
	SETZM	FSCLKF
	PUSHJ	P,FSGETK		;LOOK FOR THE 1K WE WANTED.
	JRST	FSCKZ			;THERE WASN'T ANY THERE FOR US
	PUSHJ	P,FSWAKE		;ATTEMPT TO WAKE A WAITER.
	JRST	FSCKZ			;AVOID ATTEMP TO GIVE BACK 1K

FSCLK1:	SKIPN	FSGVKF			;MAYBE THERE'S A 1K BLOCK TO GIVE BACK?
	JRST	FSCKZ			;NOPE.
	MOVE	TAC,MEMPAG
	PUSHJ	P,CORGB1		;COMPUTE BYTE POINTER TO FIRST FS BLOCK
	LDB	TAC,TAC			;GET THE CORTAB ENTRY
	CAIE	TAC,105			;IS IT A REGULAR FREE BLOCK?
	JRST	FSCKZ			;NO, CAN'T RETURN IT TO USERS
	SETZM	FSGVKF
	HRRZ	BLOCK,@MEMSIZ		;POINTER TO TOP OF BOTTOM BLOCK
	LDB	SIZE,FSSBYP		;GET THE SIZE FIELD
	CAIGE	SIZE,1000		;SKIP IF BIG ENOUGH
	JRST	FSCKZ
	PUSHJ	P,FSGCL			;ATTEMPT TO CLAIM THIS BLOCK
	JRST	FSCKZ			;LOSE
	LDB	SIZE,FSSBYP		;GET THE SIZE
	MOVEI	TEM,(BLOCK)		;GET THE BLOCK ADDRESS
	SUBI	TEM,-1(SIZE)		;GET THE BOTTOM ADDRESS
	HRROM	BLOCK,(TEM)		;CLAIM THE BOTTOM
	CAIL	SIZE,1000		;SKIP IF SMALLER THAN A BREADBOX
	CAME	TEM,MEMSIZ		;BIG ENOUGH. AT BOTTOM?
	JRST	FSGVK3			;NO. GIVE IT ALL BACK.
	SUBI	SIZE,1000		;FIGURE SIZE OF NEW BLOCK
	JUMPE	SIZE,FSGVK1		;THERE'S NOTHING TO SPLIT
	DPB	SIZE,FSSBYP		;SET SIZE FIELD IN BLOCK
	SUBM	BLOCK,SIZE		;GET THE BOTTOM ADDRESS
	HRROM	BLOCK,1(SIZE)		;SET THE BOTTOM MARK
	MOVEI	BLOCK,2(SIZE)		;GET THE ADDRESS FOR FSGIVE
	SETOM	(SIZE)			;MAKE HI END OF K LOOK CLAIMED.
	PUSHJ	P,FSGIVX		;GIVE BACK THIS PART OF THE BLOCK
FSGVK1:	MOVEI	TAC,1000
	ADDM	TAC,MEMSIZ
	ADDM	TAC,CORMAX
	AOS	CORTAL
	MOVE	LOC,MEMPAG
	AOS	MEMPAG

IFN FTEXPG,<	MOVEI	TAC1,(LOC)
		PUSHJ	P,DELEMP	;DELETE PAGE FROM EXEC MAP >;IFN FTEXPG

	PUSHJ	P,CORGBP
	MOVEI	TAC1,0
	DPB	TAC1,TAC
IFN FTCORBUG,<	PUSHJ	P,CORCHK  >	;MAKE SURE CORTAB AND CORTAL ARE CONSISTENT
	PUSHJ	P,DIDLE4
	SETOM	FSGVKF			;FLAG FOR NEXT TICK JUST IN CASE 
	JRST	FSCKZ

FSGVK3:	MOVEI	BLOCK,1(TEM)		;GET THE BOTTOM DATA WORD ADDRESS
	PUSHJ	P,FSGIVX		;GIVE BACK THIS BLOCK!
FSCKZ:	SKIPLE	FSCKCT			;TIME TO DO CHECKERBOARD?
	JRST	FSCLK3			;NO.
	MOVE	BLOCK,RMEMSIZ
	SUB	BLOCK,MEMSIZ
	SUB	BLOCK,FSBUSY
	CAILE	BLOCK,5000		;SKIP IF LESS THAN 2.5 FREE
	JRST	FSCLK4			;TOO MUCH IS FREE.
	MOVEI	BLOCK,=30*JIFSEC	;LOOK AGAIN IN 30 SECONDS.
	MOVEM	BLOCK,FSCKCT
FSCLK3:	XSYNC	FSCSC
	POPJ	P,

FSCLK4:	XSYNC	FSCSC
	MOVEI	BLOCK,=10*JIFSEC
	MOVEM	BLOCK,FSCKCT
	JRST	RELEX			;RELEASE SPARES.

LOSYS

FSCKX:	SKIPN	FSRTL			;ANY ONE ON THE RETURN LIST?
	POPJ	P,			;NO. RETURN
	CONO	PI,PIOFF		;DON'T INTERRUPT
	HRRZ	BLOCK,FSRTL		;GET THE FORWARD LINK
	MOVE	TAC,(BLOCK)		;GET THE NEXT FLINK
	HRRZM	TAC,FSRTL		;SAVE IT HERE
	CONO	PI,PION			;TURN ON THE PI'S
	LDB	TAC,FSSBYP		;GET THE SIZE FIELD
	SUBI	BLOCK,-2(TAC)		;GET THE ADDRESS OF LOWEST DATA WORD
	PUSHJ	P,FSGIVX		;ALL SET TO GIVE THE BLOCK BACK AGAIN
	JRST	FSCKX			;LOOK FOR MORE
;FSQUIK, FSGIVE - RETURN FREE STORAGE TO SYSTEM.

COMMENT $


CALLING:
	MOVE	BLOCK,<ADDRESS OF BLOCK>
	PUSHJ	P,FSGIVE
	<RETURN HERE ALWAYS>

FSGIVX IS ROUTINE FOR FSGIVE THAT DOESN'T SAVE AC'S 
USE THIS ONLY INSIDE OF FS ROUTINES!

$


FSECHK:	PUSH	P,BLOCK			;SAVE AC'S FOR A WHILE.
	PUSH	P,SIZE			;SAVE.
	CAMGE	BLOCK,RMEMSIZ
	CAMG	BLOCK,MEMSIZ
	JRST	FSECK0			;OUT OF BOUNDS
	SUBI	BLOCK,1
	TRNE	BLOCK,TRIVIAL-1		;ALL THESE BITS MUST BE OFF!
	JRST	FSECK1			;BAD ALLIGNMENT
	MOVE	SIZE,(BLOCK)		;GET BOTTOM LINK
	TLC	SIZE,-1
	TLNE	SIZE,-1
	JRST	FSECK2			;BOTTOM LINK  LEFT HALF NOT -1
	CAMGE	SIZE,RMEMSIZ
	CAMG	SIZE,MEMSIZ
	JRST	FSECK3			;BOTTOM LINK POINTS TO GARBAGE
	CAIG	SIZE,(BLOCK)
	JRST	FSECK4			;BOTTOM LINK POINTS BELOW BOTTOM WORD.
	TRC	SIZE,TRIVIAL-1
	TRCE	SIZE,TRIVIAL-1
	JRST	FSECK5			;BAD ALIGNMENT ON TOP BLOCK
	HLRZ	BLOCK,(SIZE)		;GET 400000+SIZE OF THIS BLOCK
	SUBI	SIZE,-400002(BLOCK)	;MAKE POINTER TO 1 ABOVE THE BOTTOM
	CAME	SIZE,-1(P)		;MAKE SURE THESE ARE THE SAME.
	JRST	FSECK6			;ALLEDGED TOP DOESN'T POINT TO BOTTOM.
	POP	P,SIZE
	POP	P,BLOCK
	POPJ	P,

FSECK0:	JSP	BLOCK,FSECKX		;ERROR 0 - OUT OF BOUNDS
FSECK1:	JSP	BLOCK,FSECKX		;ERROR 1 - BAD ALIGNMENT
FSECK2:	JSP	BLOCK,FSECKX		;ERROR 2 - BOTTOM LINK LEFT HALF NOT -1
FSECK3:	JSP	BLOCK,FSECKX		;ERROR 3 - BOTTOM LINK POINTS OUTSIDE FS
FSECK4:	JSP	BLOCK,FSECKX		;ERROR 4 - BOTTOM LINK POINTS BELOW ITSELF
FSECK5:	JSP	BLOCK,FSECKX		;ERROR 5 - BOTTOM LINK MISALIGNED
FSECK6:	JSP	BLOCK,FSECKX		;ERROR 6 - TOP DOESN'T POINT TO BOTTOM.
FSECKX:	SUBI	BLOCK,FSECK0+1		;NORMALIZE
	HRRZ	BLOCK,BLOCK
	PUSHACS	
	PUSH	P,BLOCK
	PUSHJ	P,DISMES
	ASCIZ	/RELEASE OF NON-EX FREE STORAGE BLOCK. BLOCK = /
	MOVE	TAC,-22(P)	;REACH BACK AND PULL UP STINKING MESS.
	PUSHJ	P,DISLOC
	PUSHJ	P,DISMES
	ASCIZ	/
CALLERS ADDRESS = /
	MOVE	TAC,-24(P)
	PUSHJ	P,DISLOC
	PUSHJ	P,DISMES
	ASCIZ	/;  ERROR CODE = /
	POP	P,BLOCK
	PUSHJ	P,DISLOC
	PUSHJ	P,DISCRLF
	PUSHJ	P,DISFLUSH		;MAKE SURE WE CAN SEE MESSAGE.
	POPACS
	PUSHJ	P,WDDTCAL
	POP	P,SIZE
	POP	P,TAC
	POP	P,(P)		;THROW OUT RETURN FROM FSCHEK
	POPJ	P,		;RETURN TO BASTARD WHO CALLED ME.

↑FSGIVE:ANDI	BLOCK,-1		;FLUSH LEFT HALF
	PUSHJ	P,FSECHK		;CHECK FOR WINNING ADDRESSES
	AOS	NFSGIVES		;INCREMENT COUNT OF GIVES
	PUSH	P,BLOCK			;SAVE THIS FOR A WHILE.
	HRRZ	BLOCK,-1(BLOCK)		;GET THE TOP ADDRESS
	LDB	BLOCK,FSSBYP		;GET THE SIZE
	MOVN	BLOCK,BLOCK		;GET -SIZE
	ADDM	BLOCK,FSBUSY		;DECREASE BUSY COUNT
	POP	P,BLOCK			;RESTORE BLOCK.
	CONSZ	PI,77000		;SKIP IF WE'RE NOT IN CHANNELS 1-6
	JRST	FSQUK1			;DO THE QUICK STUFF!
	PUSHJ	P,FSACSV		;SAVE AC'S
	PUSHJ	P,FSGIVY		;NOW GO GIVE BACK FREE STORAGE
	JSP	DAT,FSACRS		;RESTORE AC'S
	POPJ	P,			;RETURN

FSGIVX:	PUSHJ	P,FSECHK		;CHECK FOR ERROR.
	CONSZ	PI,77000		;SKIP IF AT LOW LEVEL
	JRST	FSQUK1			;AT HI CHANNEL GIVE BACK QUICK
FSGIVY:	PUSH	P,BLOCK			;SAVE BLOCK
	PSYNC	FSCSC			;LOCK OUT OTHER PROCESSOR
	MOVEI	AC2,-2(BLOCK)		;AC2 ← HIGH ADDRESS OF LOWER BLOCK
	HRRZ	BLOCK,-1(BLOCK)		;BLOCK SET TO TOP WORD OF THIS BLOCK
	LDB	TAC,[POINT 9,AC2,26]
	PUSHJ	P,CORGB1		;BYTE POINTER TO CORTAB
	LDB	TAC,TAC
	CAIE	TAC,105			;SKIP IF BLOCK IS ABOVE AN FS AREA.
	JRST	FSGV1			;NO.  EITHER AT BOTTOM OF FS OR ABOVE PMAP
	PUSH	P,BLOCK			;SAVE BLOCK TOP!
	MOVE	BLOCK,AC2		;GET THE ADDRESS OF LOWER
	PUSHJ	P,FSGCL			;ATTEMPT TO CLAIM LOWER
	JRST	FSGV0			;POP BLOCK AND FORGET ABOUT LOW MERGE
	LDB	TEM,FSSBYP		;GET THE SIZE
	MOVEI	DAT,(BLOCK)
	SUBI	DAT,(TEM)		;GET THE BOTTOM ADDRESS - 1
	POP	P,BLOCK			;GET ADDRESS OF TOP OF BIG BLOCK
	LDB	TAC1,FSSBYP		;GET SIZE OF ORIGINAL
	ADD	TEM,TAC1		;SUM THEM
	DPB	TEM,FSSBYP		;STUFF THEM IN THE ORIGINAL
	HRROM	BLOCK,1(DAT)		;SAVE A BOUNDARY MARKER.
	JRST	FSGV1
FSGV0:	POP	P,BLOCK			;GET THE TOP OF THIS BLOCK BACK.
FSGV1:	MOVEI	TAC,(BLOCK)		;GET ADDRESS OF GUY ABOVE
	ADDI	TAC,1			;  (SINCE MOVEI MIGHT OVERFLOW)
	LSH	TAC,-=9
	PUSHJ	P,CORGB1		;GET A BYTE POINTER INTO TAC
	LDB	TAC,TAC			;GET CORTAB BYTE
	CAIE	TAC,105			;SKIP IF NEXT HIGHER ADDRESS IS IN FS.
	JRST	FSGV2A			;ABOVE THIS BLOCK IS NOT MORE FS.
	HRRZ	TAC1,1(BLOCK)		;GET BOTTOM POINTER OF GUY ABOVE
	CONI	PI,DAT
	ANDI	DAT,PICMSK
	CONO	PI,PICHOF(DAT)		;STOP CHANNELS 3-7
	HRRZ	AC2,1(BLOCK)		;GET THE BOTTOM POINTER
	SKIPG	TAC,(AC2)		;GET THE FLINK
	JRST	FSGV2			;ALL A BAD IDEA.
	MOVE	TAC1,-1(AC2)		;GET THE BLINK
	HRRM	TAC1,-1(TAC)		;GO FORWARD AND STUFF BLINK
	HRRM	TAC,(TAC1)		;GO BACK AND SET FLINK
	CONO	PI,PICHON(DAT)		;ALLOW INTERRUPTS AGAIN
	MOVSI	DAT,400000
	IORM	DAT,(AC2)		;CLAIM THIS BLOCK.
	LDB	TAC,FSSBP1		;GET THE SIZE OF THIS GUY
	LDB	SIZE,FSSBYP
	ADD	SIZE,TAC
	MOVE	DAT,AC2
	SUB	DAT,SIZE		;COMPUTE THE BOTTOM ADDRESS
	DPB	SIZE,FSSBP1
	HRROM	AC2,1(DAT)
	SKIPA	BLOCK,AC2
FSGV2:	CONO	PI,PICHON(DAT)
FSGV2A:	LDB	SIZE,FSSBYP
	LSH	SIZE,1-TSHF		;SHIFT SIZE TO MAKE INDEX.
	SUBI	SIZE,2			;FIX INDEX.
	CAIL	SIZE,NFSB*2		;REASONABLE INDEX?
	MOVEI	SIZE,NFSB*2-2		;NO. FIX INDEX.
	JRST	FSGV6
FSGV5:	CONO	PI,PICHON(TAC1)		;MAKE SURE PI'S GET RESTORED
FSGV6:	MOVEI	TAC,FSAVB+1(SIZE)	;GET THE LIST BASE
FSGV7:	SKIPG	DAT,(TAC)		;DOES THIS POINT FREE?
	JRST	FSGV6			;NO TRY THIS LIST ALL OVER AGAIN
	HRRZ	TEM,(TAC)		;GET THE FLINK
	CAIGE	TEM,(BLOCK)		;HAVE WE FOUND THE RIGHT PLACE?
	JRST	FSGV8			;YES. PREPARE TO LINK IT IN
	CAME	DAT,(TAC)		;IS THIS STILL THE SAME?
	JRST	FSGV6			;NO. TRY ALL OVER
	MOVEI	TAC,(TEM)		;GET THE NEXT FLINK
	JRST	FSGV7			;CHASE DOWN THIS LIST

FSGV8:	HRRZM	TAC,-1(BLOCK)		;SET THE BLINK
	HRRM	TEM,(BLOCK)		;SET THE FLINK
	LDB	AC2,FSSBYP		;GET THE SIZE OF BLOCK
	SUBM	BLOCK,AC2		;GET POINTER TO BOTTOM
	MOVSI	SIZE,400000
	ANDCAM	SIZE,(BLOCK)		;TURN OFF CLAIM BIT
	CONI	PI,TAC1
	ANDI	TAC1,PICMSK
	CONO	PI,PICHOF(TAC1)		;HOLD CHANNELS 3-7
	CAME	DAT,(TAC)		;STILL HERE?
	JRST	FSGV5			;WHAT A LOSS.
	HRRM	BLOCK,(TAC)		;STUFF IN NEW FLINK
	HRRM	BLOCK,-1(TEM)		;STUFF IN NEW BLINK
	HRRZM	BLOCK,1(AC2)		;AND TURN OFF BOTTOM MARK
	CONO	PI,PICHON(TAC1)		;ALLOW INTERRUPTS
	HRRZ	BLOCK,@MEMSIZ		;POINTER TO BOTTOM-MOST FS BLOCK
	LDB	SIZE,FSSBYP		;GET THE SIZE OF LOW BLOCK
	SKIPL	(BLOCK)			;SKIP IF BLOCK IS CLAIMED ALREADY
	CAIGE	SIZE,2000		;UNCLAIMED. SKIP IF BIGGER THAN 1K
	JRST	FSXPOP			;CLAIMED OR NOT BIG ENOUGH
	SKIPN	FSCNT			;SKIP IF ANYONE'S WAITING
	SETOM	FSGVKF			;SET FLAG TO LET CLOCK THINK ABOUT IT
	SETOM	FSNCLK			;MAKE CLKSER CALL FSCLK
FSXPOP:	PUSH	P,J			;SAVE J, CLOBBERED BY FSWAKE
	SKIPN	PID			;P2 CAN'T WAKE ANYONE.
	PUSHJ	P,FSWAKE		;WAKE SOMEONE WHO WAITS.
	POP	P,J			;RESTORE J
FSPOP:	POP	P,BLOCK
	XSYNC	FSCSC
	POPJ	P,


FSQUIK:	PUSHJ	P,FSECHK		;CHECK ADDRESSES
FSQUK1:	PUSH	P,BLOCK
	PUSH	P,TEM
	HRRZ	BLOCK,-1(BLOCK)		;LOAD TOP ADDRESS FROM BOTTOM
	PSYNC	FSCSC
	CONO	PI,PIOFF		;ADD THIS BLOCK TO THE FREE LIST
	HRRZ	TEM,FSRTL		;GET THE FLINK
	HRRM	TEM,(BLOCK)		;SAVE HERE
	HRRZM	BLOCK,FSRTL		;RESET LIST BASE
	CONO	PI,PION			;DONE
	SETOM	FSNCLK
	POP	P,TEM
	JRST	FSPOP
;GET FREE STORAGE AT UUO LEVEL.

HISYS

↑UFSGET:
	PUSHJ	P,FSGET			;GET FREE STORAGE AT UUO LEVEL
	JRST	.+2			;FAILURE CANNOT HAPPEN (IT SAYS HERE)
	POPJ	P,			;EXPECTED RETURN
	PUSHACS				;STUFF EVERYTHING AWAY
	PUSHJ	P,DISDATE
	PUSHJ	P,DISMES
	ASCIZ	/NO FS AT UFSGET. /
	CONSO	PI,77400		;ARE THERE ANY CHANNELS ACTIVE?
	JRST	UFSGT1			;NO.
	PUSHJ	P,DISMES
	ASCIZ	/NOT AT UUO LEVEL!  RETURN PC = /
	MOVE	TAC,P-17(P)
	PUSHJ	P,DISOCT
	PUSHJ	P,DISMES
	ASCIZ	/ PI = /
	CONI	PI,TAC
	PUSHJ	P,DISLOC
UFSGT1:	PUSHJ	P,DISCRLF
	POPACS
	JSP	DAT,UERROR		;GIVE A UUO ERROR.
;RELPDL - RELEASE THE JBTPDL
;CALL:	MOVE	J,<JOB NUMBER>
;	PUSHJ	P,RELPDL

COMMENT $

The free storage block that this PDL uses will be placed on the free
storage return list.  The block will actually be returned the next
time that channel 7 is activated by the clock.  The caller of RELPDL
must finish using the PDL at UUO level or clock level, whichever
level RELPDL is called from.

$


↑RELPDL:HRRZ	BLOCK,JBTPDL(J)		;GET THE ADDRESS OF THE PDL
	JUMPE	BLOCK,CPOPJ		;NO PDL, CAN'T RELEASE
	HRRZ	TAC,JBTPDL(J)		;GET THE PDL ADDRESS
	ADDI	TAC,JBTPLN+JOBPRT-JOBPFI	;ADDRESS OF THE TOP IN TAC
	SKIPN	(TAC)			;LOOK FOR A NON-ZERO CELL
	SOJGE	TAC,.-1			;LOOP.
	SUB	TAC,BLOCK		;SUBTRACT THE BASE ADDRESS.
	CAMLE	TAC,NPUSHD		;BIGGER THAN OUR BIGGEST
	MOVEM	TAC,NPUSHD		;YES. SAVE THIS NUMBER
	SETZM	JBTPDL(J)		;CLEAR PDL CELL FOR NEXT JOB
	AOS	NFSGIVES		;COUNT THIS CELL HERE, SINCE FAKING IT
	MOVNI	TAC,JBTPLN+2		;GET THE SIZE OF THIS BLOCK
	ADDM	TAC,FSBUSY		;DECREASE BUSY COUNT TOO.
	AOJA	BLOCK,FSQUIK		;CHECK BLOCK, STUFF ON FSRTL, RETURN
;SPARE LIST HANDLER FOR DPYSER & TTYSER -- SFSINI SFSCLK

;HERE WE SET UP THE INITIAL QUOTAS (QUOTAE?)
SFSINI:	HRRZ DDB,SFHEAD		;THE SPARE LIST LIST
SFSIOL:	LDB DAT,[331000,,SFSIZE(DDB)]	;HOW MANY DOES THIS ONE WANT?
	JUMPE DAT,SFSI2		;NONE?
	HRRZ AC3,SFSIZE(DDB)
	MOVEI AC2,(DDB)		;INIT PNTR FOR LINKING
SFSIIL:	PUSHJ P,FSGETU
	JRST .+4		;LOSE - SET TO TRY LATER (SHOULDN'T HAPPEN)
	MOVEM AC1,(AC2)		;LINK IT IN
	MOVEI AC2,(AC1)
	SOJG DAT,SFSIIL
	SETZM (AC2)		;TERMINATE LIST
	MOVEM DAT,SPFSN(DDB)	;SET FROM DAT IN CASE WE LOST
	SKIPL SFSIZE(DDB)
	ADDM DAT,SPFSNT
SFSI2:	HRRZ DDB,SFLINK(DDB)
	JUMPN DDB,SFSIOL
	POPJ P,

;WE GET HERE AT CLOCK LEVEL WHEN SPFSNT>0 TO REPLENISH OUR SPARES
↑SFSCLK:HRRZ DDB,SFHEAD
SFSCL1:	SKIPLE SPFSN(DDB)	;IF THIS LIST DOESN'T NEED ANY
	SKIPGE SFSIZE(DDB)	;OR THIS ISN'T THE CLOCK-FILLED KIND
	JRST SFSCL2		;TRY NEXT LIST
SFSCLL:	HRRZ AC3,SFSIZE(DDB)
	PUSHJ P,FSGET		;TRY TO GET ONE
	JRST SFSCL2		;LOSE - DON'T BOTHER WITH THIS LIST ANY MORE
	CONO PI,PIOFF
	EXCH AC1,(DDB)		;PUT IT IN THE LIST
	MOVEM AC1,@(DDB)
	CONO PI,PION
	SOS AC1,SPFSNT		;DECREMENT TOTAL
	SOSLE SPFSN(DDB)	;& # THIS LIST
	JRST SFSCLL		;STILL NEED MORE
	JUMPLE AC1,CPOPJ	;THIS LIST ALL SET, ANY OTHERS TO DO?
SFSCL2:	HRRZ DDB,SFLINK(DDB)	;YES, TRY NEXT LIST
	JUMPN DDB,SFSCL1	;IF THERE IS ONE
	POPJ P,
;VERSION OF FSGET TO USE SPARE LIST -- SFSGET
;LIKE FSGET EXCEPT AC3 HAS SPARE LIST HEADER POINTER INSTEAD OF SIZE
;SIGN BIT (AC3) MEANS NO SKIP (OR FAILURE) RETURN
;SFNWT BIT FORCES FAILURE RETURN EVEN AT UUO LEVEL
↑SFSGET:PUSH P,AC3
	SKIPGE SFSIZE(AC3)
	JRST SFGSF		;WANTS TO TRY SPARES FIRST
SFGFS:	HRRZ AC3,SFSIZE(AC3)
	PUSHJ P,FSGETU
	JRST SFSGTS		;NO FS, TRY SPARE
SFSXIT:	POP P,AC3
SFSWIN:	JUMPGE AC3,CPOPJ1	;HERE WE HAVE WON, AND GIVE THE REQUESTED SUCCESS RETURN
	POPJ P,

SFSGTS:	PUSHJ P,SFGTS		;TRY TO GET A SPARE
	JRST SFSLUZ		;OOPS - NO SPARE, EITHER
SFSGOK:	POP P,AC3
	AOS SPFSN(AC3)		;NOW WE NEED ANOTHER
	SKIPL SFSIZE(AC3)	;AND UNLESS WE'RE KEEPING SFSCLK OUT
	AOS SPFSNT		;WE SHOULD REQUEST SERVICE FROM IT
	JRST SFSWIN

SFGSF:	PUSHJ P,SFGTS		;HERE WE TRY THE SPARES FIRST
	SKIPA AC3,(P)		;LOSE - GET THE PNTR SO WE CAN GET THE SIZE FOR FSGET
	JRST SFSGOK		;WIN - UPDATE THINGS & EXIT
	JRST SFGFS		;NOW TRY FSGET

SFGTS:	MOVEI AC3,		;PREPARE TO FLUSH LINK
	CONO PI,PIOFF		;GET SPARE FROM LIST AT @(P)
	SKIPN AC1,@-1(P)
	JRST PIONJ		;NONE
	EXCH AC3,(AC1)		;THIS ZEROES LINK TO TELL RELEX SOMETHING CHANGED
	MOVEM AC3,@-1(P)	;DELINK IT FROM THE LIST
	CONO PI,PION
	JRST CPOPJ1

SFSLUZ:	POP P,AC3
	AOS SFLOSS(AC3)		;COUNT OUR TOTAL LOSSES
	CONSO PI,77400
	JRST SFULUZ		;UUO LEVEL - NOT TOO BAD
	JUMPL AC3,SFILUZ	;IF WE CAN'T GIVE A FAILURE RETURN WE ARE IN DEEP TROUBLE
	POPJ P,			;WHEW!

SFULUZ:	TLNE AC3,SFNWT		;IF THE CALLER DOESN'T WANT TO WAIT
	JUMPGE AC3,CPOPJ	;AND HE ALLOWS FAILURE, JUST RETURN
	PUSH P,AC3
	HRRZ AC3,SFSIZE(AC3)
	PUSHJ P,UFSGET		;OTHERWISE OFF TO FSGET TO WAIT FOR IT
	JRST SFSXIT
;ARRRGH! PI LEVEL AND NO FAILURE POSSIBLE! HERE WE CURL UP AND DIE
SFILUZ:	HLRZ AC2,SFLOSS(AC3)	;MAYBE THE CONDEMNED HAS A FEW LAST WORDS
	SKIPN AC2
	MOVEI AC2,[ASCIZ /SOMETHING/]	;NOPE
	PUSHACS
	PUSHJ P,DISDAT
	PUSHJ P,DISERR
	[ASCIZ /πππππππNO CORE FOR /]
	@AC2-20(P)
	[ASCIZ / AT SFSGET.

/]
	-1
	PUSHJ P,DISFLUSH
	PUSHJ P,DDTCALL		;MAYBE SOMEONE WANTS TO KNOW WHY
	JRST AUTOLOAD		;AS THE SYSTEM SINKS SLOWLY INTO THE WEST
;VERSION OF FSGIVE TO THINK ABOUT PUTTING RETURNED BLOCK INTO SPARE LIST -- SFSGIV SFSREL
;LIKE FSGIVE BUT CALL IS FOLLOWED BY LIST HEADER ADDRESS
↑SFSGIV:PUSH P,AC3
	AOS AC3,-1(P)		;SKIP OVER ARG
	MOVEI AC3,@-1(AC3)	;& GET IT
	SKIPGE SFSIZE(AC3)	;ONLY RETURN INTO LIST IF THIS BIT IS ON
	SKIPG SPFSN(AC3)	;AND WE NEED SOME
	JRST [POP P,AC3↔JRST FSGIVE]	;OTHERWISE GIVE IT BACK TO FS
	PUSH P,AC1
	ANDI AC1,-1
	CONO PI,PIOFF
	EXCH AC1,(AC3)		;LINK IT IN
	MOVEM AC1,@(AC3)
	CONO PI,PION
	POP P,AC1
	SOS SPFSN(AC3)		;ONE FEWER NEEDED
	POP P,AC3
	POPJ P,

;ROUTINE TO DYNAMICALLY SHRINK SIZE OF SPARE LIST
;CALL WITH -# TO DECREASE IN AC2, HEADER POINTER IN AC3 (CLOBBERS AC1 & AC2)
↑SFSREL:SKIPL SFSIZE(AC3)	;AS USUAL, THIS TYPE LEAVES SPFSNT ALONE
	ADDM AC2,SPFSNT
	ADDB AC2,SPFSN(AC3)
	JUMPGE AC2,CPOPJ	;LEAVE IF WE DON'T HAVE TO GIVE ANY AWAY
SFSRLL:	CONO PI,PIOFF
	SKIPN AC1,(AC3)		;GET ONE
	JRST PIONJ		;NONE
	HRRZ AC2,(AC1)
	MOVEM AC2,(AC3)		;LINK IT OUT
	CONO PI,PION
	PUSHJ P,FSGIVE		;AND GIVE IT BACK TO THE WORLD
	SKIPL SFSIZE(AC3)	;THE UBIQUITOUS TEST (SIGH)
	AOS SPFSNT
	AOSGE SPFSN(AC3)	;ONE MORE "NEEDED" (SHOULD BE GOING UP TO 0)
	JRST SFSRLL		;AND WE'LL KEEP AT IT UNTIL IT DOES
	POPJ P,
;YES FANS, IT'S THE INFAMOUS RELEX, FORMERLY SCATTERED THROUGH TTYSER & DPYSER
;THIS ONE TRIES TO SHUFFLE UP ALL THE SPARES IN THE BOTTOM 1K
;BY REPLACING THEM WITH NEW ONES FROM FREE STORAGE
;IT GIVES UP QUICKLY IF THE NEW ONES AREN'T ABOVE THE BOTTOM 1K


RELEX:	MOVE AC2,MEMSIZ
	ADDI AC2,2000		;THIS WILL BE OUR THRESHOLD
	CAML AC2,RMEMSIZ	;BUT LEAVE THE TOP 1K ALONE
	POPJ P,		;IF THIS INSTRUCTION GETS EXECUTED SOMEONE DESERVES OUR WARMEST CONGRATULATIONS
	HLRZ DDB,SFHEAD		;THERE WAS ONCE A REASON FOR GOING THROUGH BACKWARDS
RELX1:	MOVEI TAC,(DDB)		;START THE "PREVIOUS" POINTER HERE
RELX2:	HRRZ TEM,(TAC)		;CONSIDER A BLOCK
	JUMPE TEM,RELXO		;GEE, WASN'T THAT EASY
	CAIL TEM,(AC2)
	JRST RELXI		;HE'S NOT IN THE BOTTOM 1K, SO WE WON'T WORRY ABOUT HIM NOW
	MOVE TAC1,(TEM)		;PICK UP HIS LINK
	HRRZ AC3,SFSIZE(DDB)	;HE MUST BE THIS BIG
	PUSHJ P,FSGET		;GET A SHINY NEW PIECE
	JRST RELXO		;OH WELL, SO MUCH FOR THIS LIST
	CAIGE AC1,(AC2)		;SEE IF THE NEW ONE IS ABOVE THE BOTTOM 1K
	JRST RELXL		;TIME TO SEE THE COMPLAINT DEPARTMENT
	MOVEM TAC1,(AC1)	;COPY THE LINK
	CONO PI,PIOFF		;NOW CLOSE OUR EYES
	CAMN TAC1,(TEM)		;AND IF THESE 2 POINTERS
	CAME TEM,(TAC)		;STILL AGREE
	JRST [CONO PI,PION↔JRST RELXL]	;CURSES! FOILED AGAIN! GIVE BACK NEW BLOCK.
	MOVEM AC1,(TAC)		;QUICK! PULL THE SWITCH!
	CONO PI,PION		;DIDN'T SEE A THING
	EXCH AC1,TEM		;DON'T FORGET TO TELL FSGIVE ABOUT THE SWITCH
	PUSHJ P,FSGIVE		;NOW GET RID OF THE LOSER
RELXI:	MOVE TAC,TEM		;THIS IS NOW THE PREVIOUS BLOCK
	JRST RELX2

RELXL:	PUSHJ P,FSGIVE		;GIVE BACK THE NEW ONE
RELXO:	HLRZ DDB,SFLINK(DDB)	;AND TRY A NEW LIST
	JUMPN DDB,RELX1		;IF THERE'S ONE TO BE FOUND
	POPJ P,
;GETMAP,GIVMAP	MANIPULATE 512-WORD PAGES OF FREE STORAGE.

;RETURNS IN BLOCK THE ADDRESS OF A 512-WORD PAGE MAP, CONTAINING ALL ZEROS.
;SKIPS ON SUCCESS.  CALL AT UUO-LEVEL OR FROM CHANNEL-7 ONLY!

↑GETMAP:PUSHJ	P,FSACSV		;SAVE SOME ACS
	PUSHJ	P,FSGETP		;SPECIAL FS CALL. RETURNS A PAGE
	JRST	GETMP3			;LOSE.  RESTORE ACS AND DIRECT-RETURN
	MOVEI	TAC,(BLOCK)		;MAKE INTO NEW FORMAT FS BLOCK.
	LSH	TAC,-=9
	PUSHJ	P,CORGB1		;MAKE CORTAB BYTE POINTER.
	MOVEI	AC2,110			;CODE - MAP PAGE - BUSY
	DPB	AC2,TAC			;CHANGE CORTAB ENTRY.
	SUBI	BLOCK,1			;POINTS TO THE PAGE
	MOVSI	AC2,(BLOCK)
	HRRI	AC2,1(BLOCK)
	SETZM	(BLOCK)
	BLT	AC2,777(BLOCK)
	JSP	DAT,FSACRS		;SKIP RETURN, RESTORING ACS
	LSH	BLOCK,-=9		;RETURN PAGE NUMBER OF THIS PAGE.
	JRST	CPOPJ1

;RETURN A 512-WORD PAGE TO FREE STORAGE.  CALL WITH ADDRESS IN BLOCK.
↑GIVMAP:PUSHJ	P,FSACSV		;SAVE SOME ACS
	LSH	BLOCK,=9		;CONVERT TO A WORD ADDRESS
	MOVEI	TAC1,777(BLOCK)		;HIGH ADDRESS.
	MOVSI	AC2,401000		;SIZE FIELD FOR FS BLOCK.
	MOVEM	AC2,(TAC1)		;STUFF IN HIGH WORD
	HRROM	TAC1,(BLOCK)		;STUFF UP POINTER IN LOW WORD
	LDB	TAC,[POINT 9,BLOCK,26]
	PUSHJ	P,CORGB1
	MOVEI	TAC1,105		;SET CORTAB CODE TO FREE STORAGE.
	DPB	TAC1,TAC
	ADDI	BLOCK,1			;MAKE BLOCK POINT TO NORMAL STYLE FS BLOCK
	PUSHJ	P,FSGIVE		;GIVE IT AWAY
GETMP3:	JSP	DAT,FSACRS
	POPJ	P,

BEND CORE

↑HIDVBG←←0
IFN FTHSYS,<↑HIDVBG←←.>			;FTHSYS
LOSYS
↑DEVBEG←←.			;START OF THE DEV SERVICES IN ENTIRE SYSTEM
HISYS